New Crowdin updates (#724)

* New translations resources.json (Romanian)

* New translations resources.json (French)

* New translations resources.json (Spanish)

* New translations resources.json (Bulgarian)

* New translations resources.json (Catalan)

* New translations resources.json (Czech)

* New translations resources.json (Danish)

* New translations resources.json (German)

* New translations resources.json (Greek)

* New translations resources.json (Finnish)

* New translations resources.json (Italian)

* New translations resources.json (Japanese)

* New translations resources.json (Lithuanian)

* New translations resources.json (Dutch)

* New translations resources.json (Polish)

* New translations resources.json (Russian)

* New translations resources.json (Slovak)

* New translations resources.json (Turkish)

* New translations resources.json (Ukrainian)

* New translations resources.json (Chinese Simplified)

* New translations resources.json (Galician)

* New translations resources.json (Portuguese, Brazilian)

* New translations resources.json (Indonesian)

.editorconfig

@@ -149,7 +149,7 @@ csharp_preferred_modifier_order = public,private,protected,internal,static,exter
 # Code-block preferences
 csharp_prefer_braces = true:silent
 csharp_prefer_simple_using_statement = true:suggestion
-csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_namespace_declarations = file_scoped:error
 
 # Expression-level preferences
 csharp_prefer_simple_default_expression = true:suggestion
@@ -287,4 +287,6 @@ csharp_style_prefer_top_level_statements = true:silent
 csharp_style_prefer_utf8_string_literals = true:suggestion
 csharp_style_prefer_readonly_struct = true:suggestion
 csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true:silent
-csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
+csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
+csharp_style_prefer_primary_constructors = true:silent
+csharp_prefer_system_threading_lock = true:suggestion

.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,68 @@
+<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.Labs.Uwp.DependencyPropertyGenerator" Version="0.1.250206-build.2040" />
+    <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.0" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Animations" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Behaviors" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.Segmented" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.SettingsControls" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.Sizers" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.TabbedCommandBar" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.TokenizingTextBox" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Extensions" Version="8.2.250402" />
+    <PackageVersion Include="CommunityToolkit.Uwp.Controls.Primitives" Version="8.2.250129-preview2" />
+    <PackageVersion Include="EmailValidation" Version="1.3.0" />
+    <PackageVersion Include="gravatar-dotnet" Version="0.1.3" />
+    <PackageVersion Include="HtmlAgilityPack" Version="1.12.0" />
+    <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.13.0" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.4" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.4" />
+    <PackageVersion Include="Microsoft.Graph" Version="5.75.0" />
+    <PackageVersion Include="Microsoft.Identity.Client" Version="4.70.1" />
+    <PackageVersion Include="Microsoft.Identity.Client.Broker" Version="4.70.1" />
+    <PackageVersion Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.70.1" />
+    <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.11.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.2" />
+    <PackageVersion Include="Sentry.Serilog" Version="5.12.0" />
+    <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.4" />
+    <PackageVersion Include="System.Text.Json" Version="9.0.4" />
+    <PackageVersion Include="Win2D.uwp" Version="1.28.2" />
+    <PackageVersion Include="H.NotifyIcon.Wpf" Version="2.3.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.11.0" />
+    <PackageVersion Include="TimePeriodLibrary.NET" Version="2.1.6" />
+    <PackageVersion Include="System.Reactive" Version="6.0.1" />
+    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="9.0.4" />
+    <PackageVersion Include="System.Text.Encodings.Web" Version="9.0.4" />
+  </ItemGroup>
+</Project>

Wino.Authentication/BaseAuthenticator.cs

@@ -0,0 +1,16 @@
+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,50 @@
+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 => string.Equals(a.Username?.Trim(), account.Address?.Trim(), StringComparison.OrdinalIgnoreCase));
+
+        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. If you are signing with a Office365, it is not officially supported yet.");
+            }
+
+            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,23 @@
+<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" />
+		<PackageReference Include="Sentry.Serilog" />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj" />
+		<ProjectReference Include="..\Wino.Messages\Wino.Messaging.csproj" />
+	</ItemGroup>
+</Project>

Wino.BackgroundTasks/Wino.BackgroundTasks.csproj

@@ -86,6 +86,9 @@
     <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>

Wino.Calendar.ViewModels/AccountDetailsPageViewModel.cs

@@ -0,0 +1,37 @@
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.ViewModels;
+using Wino.Mail.ViewModels.Data;
+using Wino.Messaging.Client.Navigation;
+
+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 void EditAccountDetails()
+            => Messenger.Send(new BreadcrumbNavigationRequested(Translator.SettingsEditAccountDetails_Title, WinoPage.EditAccountDetailsPage, Account));
+
+    public override void OnNavigatedTo(NavigationMode mode, object parameters)
+    {
+        base.OnNavigatedTo(mode, parameters);
+    }
+}

Wino.Calendar.ViewModels/AccountManagementViewModel.cs

@@ -0,0 +1,146 @@
+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);
+
+        await accountCreationDialog.ShowDialogAsync(accountCreationCancellationTokenSource);
+        await Task.Delay(500);
+
+        // 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,366 @@
+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,870 @@
+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,126 @@
+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,12 @@
+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,69 @@
+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,45 @@
+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,145 @@
+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,115 @@
+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,30 @@
+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,13 @@
+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,13 @@
+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,16 @@
+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,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<TargetFramework>net9.0</TargetFramework>
+		<Platforms>x86;x64;arm64</Platforms>
+		<RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+		<AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+		<ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+	</PropertyGroup>
+	<ItemGroup>
+	  <PackageReference Include="TimePeriodLibrary.NET" />
+	</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/Activation/DefaultActivationHandler.cs

@@ -0,0 +1,23 @@
+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

@@ -1,7 +1,31 @@
-<Application
+<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:local="using:Wino.Calendar">
+    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>
 
-</Application>

Wino.Calendar/App.xaml.cs

@@ -1,100 +1,159 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
 using Windows.ApplicationModel;
 using Windows.ApplicationModel.Activation;
-using Windows.Foundation;
-using Windows.Foundation.Collections;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Controls.Primitives;
-using Windows.UI.Xaml.Data;
-using Windows.UI.Xaml.Input;
-using Windows.UI.Xaml.Media;
-using Windows.UI.Xaml.Navigation;
+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
+namespace Wino.Calendar;
+
+public sealed partial class App : WinoApplication, IRecipient<NewCalendarSynchronizationRequested>
 {
-    /// <summary>
-    /// Provides application-specific behavior to supplement the default Application class.
-    /// </summary>
-    sealed partial class App : Application
+    private BackgroundTaskDeferral connectionBackgroundTaskDeferral;
+
+    public App()
     {
-        /// <summary>
-        /// Initializes the singleton application object.  This is the first line of authored code
-        /// executed, and as such is the logical equivalent of main() or WinMain().
-        /// </summary>
-        public App()
+        InitializeComponent();
+        WeakReferenceMessenger.Default.Register<NewCalendarSynchronizationRequested>(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)
         {
-            this.InitializeComponent();
-            this.Suspending += OnSuspending;
+            await ActivateWinoAsync(args);
         }
+    }
 
-        /// <summary>
-        /// Invoked when the application is launched normally by the end user.  Other entry points
-        /// will be used such as when the application is launched to open a specific file.
-        /// </summary>
-        /// <param name="e">Details about the launch request and process.</param>
-        protected override void OnLaunched(LaunchActivatedEventArgs e)
+    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)
         {
-            Frame rootFrame = Window.Current.Content as Frame;
+            LogActivation("OnBackgroundActivated -> AppServiceTriggerDetails received.");
 
-            // Do not repeat app initialization when the Window already has content,
-            // just ensure that the window is active
-            if (rootFrame == null)
+            // Only accept connections from callers in the same package
+            if (appServiceTriggerDetails.CallerPackageFamilyName == Package.Current.Id.FamilyName)
             {
-                // Create a Frame to act as the navigation context and navigate to the first page
-                rootFrame = new Frame();
+                // Connection established from the fulltrust process
 
-                rootFrame.NavigationFailed += OnNavigationFailed;
+                connectionBackgroundTaskDeferral = args.TaskInstance.GetDeferral();
+                args.TaskInstance.Canceled += OnConnectionBackgroundTaskCanceled;
 
-                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
-                {
-                    //TODO: Load state from previously suspended application
-                }
+                AppServiceConnectionManager.Connection = appServiceTriggerDetails.AppServiceConnection;
 
-                // Place the frame in the current Window
-                Window.Current.Content = rootFrame;
-            }
-
-            if (e.PrelaunchActivated == false)
-            {
-                if (rootFrame.Content == null)
-                {
-                    // When the navigation stack isn't restored navigate to the first page,
-                    // configuring the new page by passing required information as a navigation
-                    // parameter
-                    rootFrame.Navigate(typeof(MainPage), e.Arguments);
-                }
-                // Ensure the current window is active
-                Window.Current.Activate();
+                WeakReferenceMessenger.Default.Send(new WinoServerConnectionEstablished());
             }
         }
+    }
 
-        /// <summary>
-        /// Invoked when Navigation to a certain page fails
-        /// </summary>
-        /// <param name="sender">The Frame which failed navigation</param>
-        /// <param name="e">Details about the navigation failure</param>
-        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
+    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
         {
-            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
+            var synchronizationResultResponse = await AppServiceConnectionManager.GetResponseAsync<CalendarSynchronizationResult, NewCalendarSynchronizationRequested>(message);
+            synchronizationResultResponse.ThrowIfFailed();
         }
-
-        /// <summary>
-        /// Invoked when application execution is being suspended.  Application state is saved
-        /// without knowing whether the application will be terminated or resumed with the contents
-        /// of memory still intact.
-        /// </summary>
-        /// <param name="sender">The source of the suspend request.</param>
-        /// <param name="e">Details about the suspend request.</param>
-        private void OnSuspending(object sender, SuspendingEventArgs e)
+        catch (WinoServerException serverException)
         {
-            var deferral = e.SuspendingOperation.GetDeferral();
-            //TODO: Save application state and stop any background activity
-            deferral.Complete();
+            var dialogService = Services.GetService<ICalendarDialogService>();
+
+            dialogService.InfoBarMessage(Translator.Info_SyncFailedTitle, serverException.Message, InfoBarMessageType.Error);
         }
     }
 }

Wino.Calendar/Args/TimelineCellSelectedArgs.cs

@@ -0,0 +1,40 @@
+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,8 @@
+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,30 @@
+using Microsoft.UI.Xaml.Controls;
+using Windows.UI.Xaml;
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.Controls;
+
+public partial 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,197 @@
+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));
+    }
+}

Wino.Calendar/Controls/CustomCalendarFlipView.cs

@@ -0,0 +1,42 @@
+using Windows.UI.Xaml.Automation.Peers;
+using Windows.UI.Xaml.Controls;
+
+namespace Wino.Calendar.Controls;
+
+/// <summary>
+/// FlipView that hides the navigation buttons and exposes methods to navigate to the next and previous items with animations.
+/// </summary>
+public partial class CustomCalendarFlipView : FlipView
+{
+    private const string PART_PreviousButton = "PreviousButtonHorizontal";
+    private const string PART_NextButton = "NextButtonHorizontal";
+
+    private Button PreviousButton;
+    private Button NextButton;
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        PreviousButton = GetTemplateChild(PART_PreviousButton) as Button;
+        NextButton = GetTemplateChild(PART_NextButton) as Button;
+
+        // Hide navigation buttons
+        PreviousButton.Opacity = NextButton.Opacity = 0;
+        PreviousButton.IsHitTestVisible = NextButton.IsHitTestVisible = false;
+
+        var t = FindName("ScrollingHost");
+    }
+
+    public void GoPreviousFlip()
+    {
+        var backPeer = new ButtonAutomationPeer(PreviousButton);
+        backPeer.Invoke();
+    }
+
+    public void GoNextFlip()
+    {
+        var nextPeer = new ButtonAutomationPeer(NextButton);
+        nextPeer.Invoke();
+    }
+}

Wino.Calendar/Controls/DayColumnControl.cs

@@ -0,0 +1,77 @@
+using System;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.Controls;
+
+public partial class DayColumnControl : Control
+{
+    private const string PART_HeaderDateDayText = nameof(PART_HeaderDateDayText);
+    private const string PART_IsTodayBorder = nameof(PART_IsTodayBorder);
+    private const string PART_ColumnHeaderText = nameof(PART_ColumnHeaderText);
+
+    private const string PART_AllDayItemsControl = nameof(PART_AllDayItemsControl);
+
+    private const string TodayState = nameof(TodayState);
+    private const string NotTodayState = nameof(NotTodayState);
+
+    private TextBlock HeaderDateDayText;
+    private TextBlock ColumnHeaderText;
+    private Border IsTodayBorder;
+    private ItemsControl AllDayItemsControl;
+
+    public CalendarDayModel DayModel
+    {
+        get { return (CalendarDayModel)GetValue(DayModelProperty); }
+        set { SetValue(DayModelProperty, value); }
+    }
+
+    public static readonly DependencyProperty DayModelProperty = DependencyProperty.Register(nameof(DayModel), typeof(CalendarDayModel), typeof(DayColumnControl), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+
+    public DayColumnControl()
+    {
+        DefaultStyleKey = typeof(DayColumnControl);
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        HeaderDateDayText = GetTemplateChild(PART_HeaderDateDayText) as TextBlock;
+        ColumnHeaderText = GetTemplateChild(PART_ColumnHeaderText) as TextBlock;
+        IsTodayBorder = GetTemplateChild(PART_IsTodayBorder) as Border;
+        AllDayItemsControl = GetTemplateChild(PART_AllDayItemsControl) as ItemsControl;
+
+        UpdateValues();
+    }
+
+    private static void OnRenderingPropertiesChanged(DependencyObject control, DependencyPropertyChangedEventArgs e)
+    {
+        if (control is DayColumnControl columnControl)
+        {
+            columnControl.UpdateValues();
+        }
+    }
+
+    private void UpdateValues()
+    {
+        if (HeaderDateDayText == null || IsTodayBorder == null || DayModel == null) return;
+
+        HeaderDateDayText.Text = DayModel.RepresentingDate.Day.ToString();
+
+        // Monthly template does not use it.
+        if (ColumnHeaderText != null)
+        {
+            ColumnHeaderText.Text = DayModel.RepresentingDate.ToString("dddd", DayModel.CalendarRenderOptions.CalendarSettings.CultureInfo);
+        }
+
+        AllDayItemsControl.ItemsSource = DayModel.EventsCollection.AllDayEvents;
+
+        bool isToday = DayModel.RepresentingDate.Date == DateTime.Now.Date;
+
+        VisualStateManager.GoToState(this, isToday ? TodayState : NotTodayState, false);
+
+        UpdateLayout();
+    }
+}

Wino.Calendar/Controls/DayHeaderControl.cs

@@ -0,0 +1,56 @@
+using System;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Calendar.Controls;
+
+public partial class DayHeaderControl : Control
+{
+    private const string PART_DayHeaderTextBlock = nameof(PART_DayHeaderTextBlock);
+    private TextBlock HeaderTextblock;
+
+    public DayHeaderDisplayType DisplayType
+    {
+        get { return (DayHeaderDisplayType)GetValue(DisplayTypeProperty); }
+        set { SetValue(DisplayTypeProperty, value); }
+    }
+
+    public DateTime Date
+    {
+        get { return (DateTime)GetValue(DateProperty); }
+        set { SetValue(DateProperty, value); }
+    }
+
+    public static readonly DependencyProperty DateProperty = DependencyProperty.Register(nameof(Date), typeof(DateTime), typeof(DayHeaderControl), new PropertyMetadata(default(DateTime), new PropertyChangedCallback(OnHeaderPropertyChanged)));
+    public static readonly DependencyProperty DisplayTypeProperty = DependencyProperty.Register(nameof(DisplayType), typeof(DayHeaderDisplayType), typeof(DayHeaderControl), new PropertyMetadata(DayHeaderDisplayType.TwentyFourHour, new PropertyChangedCallback(OnHeaderPropertyChanged)));
+
+    public DayHeaderControl()
+    {
+        DefaultStyleKey = typeof(DayHeaderControl);
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        HeaderTextblock = GetTemplateChild(PART_DayHeaderTextBlock) as TextBlock;
+        UpdateHeaderText();
+    }
+
+    private static void OnHeaderPropertyChanged(DependencyObject control, DependencyPropertyChangedEventArgs e)
+    {
+        if (control is DayHeaderControl headerControl)
+        {
+            headerControl.UpdateHeaderText();
+        }
+    }
+
+    private void UpdateHeaderText()
+    {
+        if (HeaderTextblock != null)
+        {
+            HeaderTextblock.Text = DisplayType == DayHeaderDisplayType.TwelveHour ? Date.ToString("h tt") : Date.ToString("HH:mm");
+        }
+    }
+}

Wino.Calendar/Controls/WinoCalendarControl.cs

@@ -0,0 +1,299 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Calendar.Args;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Helpers;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoCalendarControl : Control
+{
+    private const string PART_WinoFlipView = nameof(PART_WinoFlipView);
+    private const string PART_IdleGrid = nameof(PART_IdleGrid);
+
+    public event EventHandler<TimelineCellSelectedArgs> TimelineCellSelected;
+    public event EventHandler<TimelineCellUnselectedArgs> TimelineCellUnselected;
+
+    public event EventHandler ScrollPositionChanging;
+
+    #region Dependency Properties
+
+    public static readonly DependencyProperty DayRangesProperty = DependencyProperty.Register(nameof(DayRanges), typeof(ObservableCollection<DayRangeRenderModel>), typeof(WinoCalendarControl), new PropertyMetadata(null));
+    public static readonly DependencyProperty SelectedFlipViewIndexProperty = DependencyProperty.Register(nameof(SelectedFlipViewIndex), typeof(int), typeof(WinoCalendarControl), new PropertyMetadata(-1));
+    public static readonly DependencyProperty SelectedFlipViewDayRangeProperty = DependencyProperty.Register(nameof(SelectedFlipViewDayRange), typeof(DayRangeRenderModel), typeof(WinoCalendarControl), new PropertyMetadata(null));
+    public static readonly DependencyProperty ActiveCanvasProperty = DependencyProperty.Register(nameof(ActiveCanvas), typeof(WinoDayTimelineCanvas), typeof(WinoCalendarControl), new PropertyMetadata(null, new PropertyChangedCallback(OnActiveCanvasChanged)));
+    public static readonly DependencyProperty IsFlipIdleProperty = DependencyProperty.Register(nameof(IsFlipIdle), typeof(bool), typeof(WinoCalendarControl), new PropertyMetadata(true, new PropertyChangedCallback(OnIdleStateChanged)));
+    public static readonly DependencyProperty ActiveScrollViewerProperty = DependencyProperty.Register(nameof(ActiveScrollViewer), typeof(ScrollViewer), typeof(WinoCalendarControl), new PropertyMetadata(null, new PropertyChangedCallback(OnActiveVerticalScrollViewerChanged)));
+
+    public static readonly DependencyProperty VerticalItemsPanelTemplateProperty = DependencyProperty.Register(nameof(VerticalItemsPanelTemplate), typeof(ItemsPanelTemplate), typeof(WinoCalendarControl), new PropertyMetadata(null, new PropertyChangedCallback(OnCalendarOrientationPropertiesUpdated)));
+    public static readonly DependencyProperty HorizontalItemsPanelTemplateProperty = DependencyProperty.Register(nameof(HorizontalItemsPanelTemplate), typeof(ItemsPanelTemplate), typeof(WinoCalendarControl), new PropertyMetadata(null, new PropertyChangedCallback(OnCalendarOrientationPropertiesUpdated)));
+    public static readonly DependencyProperty OrientationProperty = DependencyProperty.Register(nameof(Orientation), typeof(CalendarOrientation), typeof(WinoCalendarControl), new PropertyMetadata(CalendarOrientation.Horizontal, new PropertyChangedCallback(OnCalendarOrientationPropertiesUpdated)));
+    public static readonly DependencyProperty DisplayTypeProperty = DependencyProperty.Register(nameof(DisplayType), typeof(CalendarDisplayType), typeof(WinoCalendarControl), new PropertyMetadata(CalendarDisplayType.Day));
+
+    /// <summary>
+    /// Gets or sets the day-week-month-year display type.
+    /// Orientation is not determined by this property, but Orientation property.
+    /// This property is used to determine the template to use for the calendar.
+    /// </summary>
+    public CalendarDisplayType DisplayType
+    {
+        get { return (CalendarDisplayType)GetValue(DisplayTypeProperty); }
+        set { SetValue(DisplayTypeProperty, value); }
+    }
+
+    public CalendarOrientation Orientation
+    {
+        get { return (CalendarOrientation)GetValue(OrientationProperty); }
+        set { SetValue(OrientationProperty, value); }
+    }
+
+    public ItemsPanelTemplate VerticalItemsPanelTemplate
+    {
+        get { return (ItemsPanelTemplate)GetValue(VerticalItemsPanelTemplateProperty); }
+        set { SetValue(VerticalItemsPanelTemplateProperty, value); }
+    }
+
+    public ItemsPanelTemplate HorizontalItemsPanelTemplate
+    {
+        get { return (ItemsPanelTemplate)GetValue(HorizontalItemsPanelTemplateProperty); }
+        set { SetValue(HorizontalItemsPanelTemplateProperty, value); }
+    }
+
+    public DayRangeRenderModel SelectedFlipViewDayRange
+    {
+        get { return (DayRangeRenderModel)GetValue(SelectedFlipViewDayRangeProperty); }
+        set { SetValue(SelectedFlipViewDayRangeProperty, value); }
+    }
+
+    public ScrollViewer ActiveScrollViewer
+    {
+        get { return (ScrollViewer)GetValue(ActiveScrollViewerProperty); }
+        set { SetValue(ActiveScrollViewerProperty, value); }
+    }
+
+    public WinoDayTimelineCanvas ActiveCanvas
+    {
+        get { return (WinoDayTimelineCanvas)GetValue(ActiveCanvasProperty); }
+        set { SetValue(ActiveCanvasProperty, value); }
+    }
+
+    public bool IsFlipIdle
+    {
+        get { return (bool)GetValue(IsFlipIdleProperty); }
+        set { SetValue(IsFlipIdleProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets or sets the collection of day ranges to render.
+    /// Each day range usually represents a week, but it may support other ranges.
+    /// </summary>
+    public ObservableCollection<DayRangeRenderModel> DayRanges
+    {
+        get { return (ObservableCollection<DayRangeRenderModel>)GetValue(DayRangesProperty); }
+        set { SetValue(DayRangesProperty, value); }
+    }
+
+    public int SelectedFlipViewIndex
+    {
+        get { return (int)GetValue(SelectedFlipViewIndexProperty); }
+        set { SetValue(SelectedFlipViewIndexProperty, value); }
+    }
+
+    #endregion
+
+    private WinoCalendarFlipView InternalFlipView;
+    private Grid IdleGrid;
+
+    public WinoCalendarControl()
+    {
+        DefaultStyleKey = typeof(WinoCalendarControl);
+        SizeChanged += CalendarSizeChanged;
+    }
+
+    private static void OnCalendarOrientationPropertiesUpdated(DependencyObject calendar, DependencyPropertyChangedEventArgs e)
+    {
+        if (calendar is WinoCalendarControl control)
+        {
+            control.ManageCalendarOrientation();
+        }
+    }
+
+    private static void OnIdleStateChanged(DependencyObject calendar, DependencyPropertyChangedEventArgs e)
+    {
+        if (calendar is WinoCalendarControl calendarControl)
+        {
+            calendarControl.UpdateIdleState();
+        }
+    }
+
+
+    private static void OnActiveVerticalScrollViewerChanged(DependencyObject calendar, DependencyPropertyChangedEventArgs e)
+    {
+        if (calendar is WinoCalendarControl calendarControl)
+        {
+            if (e.OldValue is ScrollViewer oldScrollViewer)
+            {
+                calendarControl.DeregisterScrollChanges(oldScrollViewer);
+            }
+
+            if (e.NewValue is ScrollViewer newScrollViewer)
+            {
+                calendarControl.RegisterScrollChanges(newScrollViewer);
+            }
+
+            calendarControl.ManageHighlightedDateRange();
+        }
+    }
+
+
+    private static void OnActiveCanvasChanged(DependencyObject calendar, DependencyPropertyChangedEventArgs e)
+    {
+        if (calendar is WinoCalendarControl calendarControl)
+        {
+            if (e.OldValue is WinoDayTimelineCanvas oldCanvas)
+            {
+                // Dismiss any selection on the old canvas.
+                calendarControl.DeregisterCanvas(oldCanvas);
+            }
+
+            if (e.NewValue is WinoDayTimelineCanvas newCanvas)
+            {
+                calendarControl.RegisterCanvas(newCanvas);
+            }
+
+            calendarControl.ManageHighlightedDateRange();
+        }
+    }
+
+    private void ManageCalendarOrientation()
+    {
+        if (InternalFlipView == null || HorizontalItemsPanelTemplate == null || VerticalItemsPanelTemplate == null) return;
+
+        InternalFlipView.ItemsPanel = Orientation == CalendarOrientation.Horizontal ? HorizontalItemsPanelTemplate : VerticalItemsPanelTemplate;
+    }
+
+    private void ManageHighlightedDateRange()
+        => SelectedFlipViewDayRange = InternalFlipView.SelectedItem as DayRangeRenderModel;
+
+    private void DeregisterCanvas(WinoDayTimelineCanvas canvas)
+    {
+        if (canvas == null) return;
+
+        canvas.SelectedDateTime = null;
+        canvas.TimelineCellSelected -= ActiveTimelineCellSelected;
+        canvas.TimelineCellUnselected -= ActiveTimelineCellUnselected;
+    }
+
+    private void RegisterCanvas(WinoDayTimelineCanvas canvas)
+    {
+        if (canvas == null) return;
+
+        canvas.SelectedDateTime = null;
+        canvas.TimelineCellSelected += ActiveTimelineCellSelected;
+        canvas.TimelineCellUnselected += ActiveTimelineCellUnselected;
+    }
+
+    private void RegisterScrollChanges(ScrollViewer scrollViewer)
+    {
+        if (scrollViewer == null) return;
+
+        scrollViewer.ViewChanging += ScrollViewChanging;
+    }
+
+    private void DeregisterScrollChanges(ScrollViewer scrollViewer)
+    {
+        if (scrollViewer == null) return;
+
+        scrollViewer.ViewChanging -= ScrollViewChanging;
+    }
+
+    private void ScrollViewChanging(object sender, ScrollViewerViewChangingEventArgs e)
+        => ScrollPositionChanging?.Invoke(this, EventArgs.Empty);
+
+    private void CalendarSizeChanged(object sender, SizeChangedEventArgs e)
+    {
+        if (ActiveCanvas == null) return;
+
+        ActiveCanvas.SelectedDateTime = null;
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        InternalFlipView = GetTemplateChild(PART_WinoFlipView) as WinoCalendarFlipView;
+        IdleGrid = GetTemplateChild(PART_IdleGrid) as Grid;
+
+        UpdateIdleState();
+        ManageCalendarOrientation();
+    }
+
+    private void UpdateIdleState()
+    {
+        InternalFlipView.Opacity = IsFlipIdle ? 0 : 1;
+        IdleGrid.Visibility = IsFlipIdle ? Visibility.Visible : Visibility.Collapsed;
+    }
+
+    private void ActiveTimelineCellUnselected(object sender, TimelineCellUnselectedArgs e)
+        => TimelineCellUnselected?.Invoke(this, e);
+
+    private void ActiveTimelineCellSelected(object sender, TimelineCellSelectedArgs e)
+        => TimelineCellSelected?.Invoke(this, e);
+
+    public void NavigateToDay(DateTime dateTime) => InternalFlipView.NavigateToDay(dateTime);
+
+    public async void NavigateToHour(TimeSpan timeSpan)
+    {
+        if (ActiveScrollViewer == null) return;
+
+        // Total height of the FlipViewItem is the same as vertical ScrollViewer to position day headers.
+
+        await Task.Yield();
+        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
+        {
+            double hourHeght = 60;
+            double totalHeight = ActiveScrollViewer.ScrollableHeight;
+            double scrollPosition = timeSpan.TotalHours * hourHeght;
+
+            ActiveScrollViewer.ChangeView(null, scrollPosition, null, disableAnimation: false);
+        });
+    }
+    public void ResetTimelineSelection()
+    {
+        if (ActiveCanvas == null) return;
+
+        ActiveCanvas.SelectedDateTime = null;
+    }
+
+    public void GoNextRange()
+    {
+        if (InternalFlipView == null) return;
+
+        InternalFlipView.GoNextFlip();
+    }
+
+    public void GoPreviousRange()
+    {
+        if (InternalFlipView == null) return;
+
+        InternalFlipView.GoPreviousFlip();
+    }
+
+    public void UnselectActiveTimelineCell()
+    {
+        if (ActiveCanvas == null) return;
+
+        ActiveCanvas.SelectedDateTime = null;
+    }
+
+    public CalendarItemControl GetCalendarItemControl(CalendarItemViewModel calendarItemViewModel)
+    {
+        return this.FindDescendants<CalendarItemControl>().FirstOrDefault(a => a.CalendarItem == calendarItemViewModel);
+    }
+}

Wino.Calendar/Controls/WinoCalendarFlipView.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.WinUI;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Core.Domain.Collections;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoCalendarFlipView : CustomCalendarFlipView
+{
+    public static readonly DependencyProperty IsIdleProperty = DependencyProperty.Register(nameof(IsIdle), typeof(bool), typeof(WinoCalendarFlipView), new PropertyMetadata(true));
+    public static readonly DependencyProperty ActiveCanvasProperty = DependencyProperty.Register(nameof(ActiveCanvas), typeof(WinoDayTimelineCanvas), typeof(WinoCalendarFlipView), new PropertyMetadata(null));
+    public static readonly DependencyProperty ActiveVerticalScrollViewerProperty = DependencyProperty.Register(nameof(ActiveVerticalScrollViewer), typeof(ScrollViewer), typeof(WinoCalendarFlipView), new PropertyMetadata(null));
+
+    /// <summary>
+    /// Gets or sets the active canvas that is currently displayed in the flip view.
+    /// Each day-range of flip view item has a canvas that displays the day timeline.
+    /// </summary>
+    public WinoDayTimelineCanvas ActiveCanvas
+    {
+        get { return (WinoDayTimelineCanvas)GetValue(ActiveCanvasProperty); }
+        set { SetValue(ActiveCanvasProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets or sets the scroll viewer that is currently active in the flip view.
+    /// It's the vertical scroll that scrolls the timeline only, not the header part that belongs
+    /// to parent FlipView control.
+    /// </summary>
+    public ScrollViewer ActiveVerticalScrollViewer
+    {
+        get { return (ScrollViewer)GetValue(ActiveVerticalScrollViewerProperty); }
+        set { SetValue(ActiveVerticalScrollViewerProperty, value); }
+    }
+
+    public bool IsIdle
+    {
+        get { return (bool)GetValue(IsIdleProperty); }
+        set { SetValue(IsIdleProperty, value); }
+    }
+
+    public WinoCalendarFlipView()
+    {
+        RegisterPropertyChangedCallback(SelectedIndexProperty, new DependencyPropertyChangedCallback(OnSelectedIndexUpdated));
+        RegisterPropertyChangedCallback(ItemsSourceProperty, new DependencyPropertyChangedCallback(OnItemsSourceChanged));
+    }
+
+    private static void OnItemsSourceChanged(DependencyObject d, DependencyProperty e)
+    {
+        if (d is WinoCalendarFlipView flipView)
+        {
+            flipView.RegisterItemsSourceChange();
+        }
+    }
+
+    private static void OnSelectedIndexUpdated(DependencyObject d, DependencyProperty e)
+    {
+        if (d is WinoCalendarFlipView flipView)
+        {
+            flipView.UpdateActiveCanvas();
+            flipView.UpdateActiveScrollViewer();
+        }
+    }
+
+    private void RegisterItemsSourceChange()
+    {
+        if (GetItemsSource() is INotifyCollectionChanged notifyCollectionChanged)
+        {
+            notifyCollectionChanged.CollectionChanged += ItemsSourceUpdated;
+        }
+    }
+
+    private void ItemsSourceUpdated(object sender, NotifyCollectionChangedEventArgs e)
+    {
+        IsIdle = e.Action == NotifyCollectionChangedAction.Reset || e.Action == NotifyCollectionChangedAction.Replace;
+    }
+
+    private async Task<FlipViewItem> GetCurrentFlipViewItem()
+    {
+        // TODO: Refactor this mechanism by listening to PrepareContainerForItemOverride and Loaded events together.
+        while (ContainerFromIndex(SelectedIndex) == null)
+        {
+            await Task.Delay(100);
+        }
+
+        return ContainerFromIndex(SelectedIndex) as FlipViewItem;
+
+
+    }
+
+    private void UpdateActiveScrollViewer()
+    {
+        if (SelectedIndex < 0)
+            ActiveVerticalScrollViewer = null;
+        else
+        {
+            GetCurrentFlipViewItem().ContinueWith(task =>
+            {
+                if (task.IsCompletedSuccessfully)
+                {
+                    var flipViewItem = task.Result;
+
+                    _ = Dispatcher.TryRunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
+                    {
+                        ActiveVerticalScrollViewer = flipViewItem.FindDescendant<ScrollViewer>();
+                    });
+                }
+            });
+        }
+    }
+
+    public void UpdateActiveCanvas()
+    {
+        if (SelectedIndex < 0)
+            ActiveCanvas = null;
+        else
+        {
+            GetCurrentFlipViewItem().ContinueWith(task =>
+            {
+                if (task.IsCompletedSuccessfully)
+                {
+                    var flipViewItem = task.Result;
+
+                    _ = Dispatcher.TryRunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
+                    {
+                        ActiveCanvas = flipViewItem.FindDescendant<WinoDayTimelineCanvas>();
+                    });
+                }
+            });
+        }
+    }
+
+    /// <summary>
+    /// Navigates to the specified date in the calendar.
+    /// </summary>
+    /// <param name="dateTime">Date to navigate.</param>
+    public async void NavigateToDay(DateTime dateTime)
+    {
+        await Task.Yield();
+
+        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
+        {
+            // Find the day range that contains the date.
+            var dayRange = GetItemsSource()?.FirstOrDefault(a => a.CalendarDays.Any(b => b.RepresentingDate.Date == dateTime.Date));
+
+            if (dayRange != null)
+            {
+                var navigationItemIndex = GetItemsSource().IndexOf(dayRange);
+
+                if (Math.Abs(navigationItemIndex - SelectedIndex) > 4)
+                {
+                    // Difference between dates are high.
+                    // No need to animate this much, just go without animating.
+
+                    SelectedIndex = navigationItemIndex;
+                }
+                else
+                {
+                    // Until we reach the day in the flip, simulate next-prev button clicks.
+                    // This will make sure the FlipView animations are triggered.
+                    // Setting SelectedIndex directly doesn't trigger the animations.
+
+                    while (SelectedIndex != navigationItemIndex)
+                    {
+                        if (SelectedIndex > navigationItemIndex)
+                        {
+                            GoPreviousFlip();
+                        }
+                        else
+                        {
+                            GoNextFlip();
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+    private ObservableRangeCollection<DayRangeRenderModel> GetItemsSource()
+        => ItemsSource as ObservableRangeCollection<DayRangeRenderModel>;
+}

Wino.Calendar/Controls/WinoCalendarPanel.cs

@@ -0,0 +1,293 @@
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CommunityToolkit.WinUI;
+using Itenso.TimePeriod;
+using Windows.Foundation;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Calendar.Models;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoCalendarPanel : Panel
+{
+    private const double LastItemRightExtraMargin = 12d;
+
+    // Store each ICalendarItem measurements by their Id.
+    private readonly Dictionary<ICalendarItem, CalendarItemMeasurement> _measurements = new Dictionary<ICalendarItem, CalendarItemMeasurement>();
+
+    public static readonly DependencyProperty EventItemMarginProperty = DependencyProperty.Register(nameof(EventItemMargin), typeof(Thickness), typeof(WinoCalendarPanel), new PropertyMetadata(new Thickness(0, 0, 0, 0)));
+    public static readonly DependencyProperty HourHeightProperty = DependencyProperty.Register(nameof(HourHeight), typeof(double), typeof(WinoCalendarPanel), new PropertyMetadata(0d));
+    public static readonly DependencyProperty PeriodProperty = DependencyProperty.Register(nameof(Period), typeof(ITimePeriod), typeof(WinoCalendarPanel), new PropertyMetadata(null));
+
+    public ITimePeriod Period
+    {
+        get { return (ITimePeriod)GetValue(PeriodProperty); }
+        set { SetValue(PeriodProperty, value); }
+    }
+
+    public double HourHeight
+    {
+        get { return (double)GetValue(HourHeightProperty); }
+        set { SetValue(HourHeightProperty, value); }
+    }
+
+    public Thickness EventItemMargin
+    {
+        get { return (Thickness)GetValue(EventItemMarginProperty); }
+        set { SetValue(EventItemMarginProperty, value); }
+    }
+
+    private void ResetMeasurements() => _measurements.Clear();
+
+    private double GetChildTopMargin(ICalendarItem calendarItemViewModel, double availableHeight)
+    {
+        var childStart = calendarItemViewModel.StartDate;
+
+        if (childStart <= Period.Start)
+        {
+            // Event started before or exactly at the periods tart. This might be a multi-day event.
+            // We can simply consider event must not have a top margin.
+
+            return 0d;
+        }
+
+        double minutesFromStart = (childStart - Period.Start).TotalMinutes;
+        return (minutesFromStart / 1440) * availableHeight;
+    }
+
+    private double GetChildWidth(CalendarItemMeasurement calendarItemMeasurement, double availableWidth)
+    {
+        return (calendarItemMeasurement.Right - calendarItemMeasurement.Left) * availableWidth;
+    }
+
+    private double GetChildLeftMargin(CalendarItemMeasurement calendarItemMeasurement, double availableWidth)
+        => availableWidth * calendarItemMeasurement.Left;
+
+    private double GetChildHeight(ICalendarItem child)
+    {
+        // All day events are not measured.
+        if (child.IsAllDayEvent) return 0;
+
+        double childDurationInMinutes = 0d;
+        double availableHeight = HourHeight * 24;
+
+        var periodRelation = child.Period.GetRelation(Period);
+
+        // Debug.WriteLine($"Render relation of {child.Title} ({child.Period.Start} - {child.Period.End}) is {periodRelation} with {Period.Start.Day}");
+
+        if (!child.IsMultiDayEvent)
+        {
+            childDurationInMinutes = child.Period.Duration.TotalMinutes;
+        }
+        else
+        {
+            // Multi-day event.
+            // Check how many of the event falls into the current period.
+            childDurationInMinutes = (child.Period.End - Period.Start).TotalMinutes;
+        }
+
+        return (childDurationInMinutes / 1440) * availableHeight;
+    }
+
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        ResetMeasurements();
+        return base.MeasureOverride(availableSize);
+    }
+
+    protected override Size ArrangeOverride(Size finalSize)
+    {
+        if (Period == null || HourHeight == 0d) return finalSize;
+
+        // Measure/arrange each child height and width.
+        // This is a vertical calendar. Therefore the height of each child is the duration of the event.
+        // Children weights for left and right will be saved if they don't exist.
+        // This is important because we don't want to measure the weights again.
+        // They don't change until new event is added or removed.
+        // Width of the each child may depend on the rectangle packing algorithm.
+        // Children are first categorized into columns. Then each column is shifted to the left until
+        // no overlap occurs. The width of each child is calculated based on the number of columns it spans.
+
+        double availableHeight = finalSize.Height;
+        double availableWidth = finalSize.Width;
+
+        var calendarControls = Children.Cast<ContentPresenter>();
+
+        if (!calendarControls.Any()) return base.ArrangeOverride(finalSize);
+
+        var events = calendarControls.Select(a => a.Content as CalendarItemViewModel);
+
+        LayoutEvents(events);
+
+        foreach (var control in calendarControls)
+        {
+            // We can't arrange this child.
+            if (!(control.Content is ICalendarItem child)) continue;
+
+            bool isHorizontallyLastItem = false;
+
+            double childWidth = 0,
+                childHeight = Math.Max(0, GetChildHeight(child)),
+                childTop = Math.Max(0, GetChildTopMargin(child, availableHeight)),
+                childLeft = 0;
+
+            // No need to measure anything here.
+            if (childHeight == 0) continue;
+
+            if (!_measurements.ContainsKey(child))
+            {
+                // Multi-day event.
+
+                childLeft = 0;
+                childWidth = availableWidth;
+            }
+            else
+            {
+                var childMeasurement = _measurements[child];
+
+                childWidth = Math.Max(0, GetChildWidth(childMeasurement, finalSize.Width));
+                childLeft = Math.Max(0, GetChildLeftMargin(childMeasurement, availableWidth));
+
+                isHorizontallyLastItem = childMeasurement.Right == 1;
+            }
+
+            // Add additional right margin to items that falls on the right edge of the panel.
+            double extraRightMargin = 0;
+
+            // Multi-day events don't have any margin and their hit test is disabled.
+            if (!child.IsMultiDayEvent)
+            {
+                // Max of 5% of the width or 20px max.
+                extraRightMargin = isHorizontallyLastItem ? Math.Max(LastItemRightExtraMargin, finalSize.Width * 5 / 100) : 0;
+            }
+
+            if (childWidth < 0) childWidth = 1;
+
+            // Regular events must have 2px margin
+            if (!child.IsMultiDayEvent && !child.IsAllDayEvent)
+            {
+                childLeft += 2;
+                childTop += 2;
+                childHeight -= 2;
+                childWidth -= 2;
+            }
+
+            var arrangementRect = new Rect(childLeft + EventItemMargin.Left, childTop + EventItemMargin.Top, Math.Max(childWidth - extraRightMargin, 1), childHeight);
+
+            // Make sure measured size will fit in the arranged box.
+            var measureSize = arrangementRect.ToSize();
+            control.Measure(measureSize);
+            control.Arrange(arrangementRect);
+
+            //Debug.WriteLine($"{child.Title}, Measured: {measureSize}, Arranged: {arrangementRect}");
+        }
+
+
+        return finalSize;
+    }
+
+    #region ColumSpanning and Packing Algorithm
+
+    private void AddOrUpdateMeasurement(ICalendarItem calendarItem, CalendarItemMeasurement measurement)
+    {
+        if (_measurements.ContainsKey(calendarItem))
+        {
+            _measurements[calendarItem] = measurement;
+        }
+        else
+        {
+            _measurements.Add(calendarItem, measurement);
+        }
+    }
+
+    // Pick the left and right positions of each event, such that there are no overlap.
+    private void LayoutEvents(IEnumerable<ICalendarItem> events)
+    {
+        var columns = new List<List<ICalendarItem>>();
+        DateTime? lastEventEnding = null;
+
+        foreach (var ev in events.OrderBy(ev => ev.StartDate).ThenBy(ev => ev.EndDate))
+        {
+            // Multi-day events are not measured.
+            if (ev.IsMultiDayEvent) continue;
+
+            if (ev.Period.Start >= lastEventEnding)
+            {
+                PackEvents(columns);
+                columns.Clear();
+                lastEventEnding = null;
+            }
+
+            bool placed = false;
+
+            foreach (var col in columns)
+            {
+                if (!col.Last().Period.OverlapsWith(ev.Period))
+                {
+                    col.Add(ev);
+                    placed = true;
+                    break;
+                }
+            }
+            if (!placed)
+            {
+                columns.Add(new List<ICalendarItem> { ev });
+            }
+            if (lastEventEnding == null || ev.Period.End > lastEventEnding.Value)
+            {
+                lastEventEnding = ev.Period.End;
+            }
+        }
+        if (columns.Count > 0)
+        {
+            PackEvents(columns);
+        }
+    }
+
+    // Set the left and right positions for each event in the connected group.
+    private void PackEvents(List<List<ICalendarItem>> columns)
+    {
+        float numColumns = columns.Count;
+        int iColumn = 0;
+
+        foreach (var col in columns)
+        {
+            foreach (var ev in col)
+            {
+                int colSpan = ExpandEvent(ev, iColumn, columns);
+
+                var leftWeight = iColumn / numColumns;
+                var rightWeight = (iColumn + colSpan) / numColumns;
+
+                AddOrUpdateMeasurement(ev, new CalendarItemMeasurement(leftWeight, rightWeight));
+            }
+
+            iColumn++;
+        }
+    }
+
+    // Checks how many columns the event can expand into, without colliding with other events.
+    private int ExpandEvent(ICalendarItem ev, int iColumn, List<List<ICalendarItem>> columns)
+    {
+        int colSpan = 1;
+
+        foreach (var col in columns.Skip(iColumn + 1))
+        {
+            foreach (var ev1 in col)
+            {
+                if (ev1.Period.OverlapsWith(ev.Period)) return colSpan;
+            }
+
+            colSpan++;
+        }
+
+        return colSpan;
+    }
+
+    #endregion
+}

Wino.Calendar/Controls/WinoCalendarTypeSelectorControl.cs

@@ -0,0 +1,91 @@
+using System.Windows.Input;
+using CommunityToolkit.Diagnostics;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoCalendarTypeSelectorControl : Control
+{
+    private const string PART_TodayButton = nameof(PART_TodayButton);
+    private const string PART_DayToggle = nameof(PART_DayToggle);
+    private const string PART_WeekToggle = nameof(PART_WeekToggle);
+    private const string PART_MonthToggle = nameof(PART_MonthToggle);
+    private const string PART_YearToggle = nameof(PART_YearToggle);
+
+    public static readonly DependencyProperty SelectedTypeProperty = DependencyProperty.Register(nameof(SelectedType), typeof(CalendarDisplayType), typeof(WinoCalendarTypeSelectorControl), new PropertyMetadata(CalendarDisplayType.Week));
+    public static readonly DependencyProperty DisplayDayCountProperty = DependencyProperty.Register(nameof(DisplayDayCount), typeof(int), typeof(WinoCalendarTypeSelectorControl), new PropertyMetadata(0));
+    public static readonly DependencyProperty TodayClickedCommandProperty = DependencyProperty.Register(nameof(TodayClickedCommand), typeof(ICommand), typeof(WinoCalendarTypeSelectorControl), new PropertyMetadata(null));
+
+    public ICommand TodayClickedCommand
+    {
+        get { return (ICommand)GetValue(TodayClickedCommandProperty); }
+        set { SetValue(TodayClickedCommandProperty, value); }
+    }
+
+    public CalendarDisplayType SelectedType
+    {
+        get { return (CalendarDisplayType)GetValue(SelectedTypeProperty); }
+        set { SetValue(SelectedTypeProperty, value); }
+    }
+
+    public int DisplayDayCount
+    {
+        get { return (int)GetValue(DisplayDayCountProperty); }
+        set { SetValue(DisplayDayCountProperty, value); }
+    }
+
+    private AppBarButton _todayButton;
+    private AppBarToggleButton _dayToggle;
+    private AppBarToggleButton _weekToggle;
+    private AppBarToggleButton _monthToggle;
+    private AppBarToggleButton _yearToggle;
+
+    public WinoCalendarTypeSelectorControl()
+    {
+        DefaultStyleKey = typeof(WinoCalendarTypeSelectorControl);
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        _todayButton = GetTemplateChild(PART_TodayButton) as AppBarButton;
+        _dayToggle = GetTemplateChild(PART_DayToggle) as AppBarToggleButton;
+        _weekToggle = GetTemplateChild(PART_WeekToggle) as AppBarToggleButton;
+        _monthToggle = GetTemplateChild(PART_MonthToggle) as AppBarToggleButton;
+        _yearToggle = GetTemplateChild(PART_YearToggle) as AppBarToggleButton;
+
+        Guard.IsNotNull(_todayButton, nameof(_todayButton));
+        Guard.IsNotNull(_dayToggle, nameof(_dayToggle));
+        Guard.IsNotNull(_weekToggle, nameof(_weekToggle));
+        Guard.IsNotNull(_monthToggle, nameof(_monthToggle));
+        Guard.IsNotNull(_yearToggle, nameof(_yearToggle));
+
+        _todayButton.Click += TodayClicked;
+
+        _dayToggle.Click += (s, e) => { SetSelectedType(CalendarDisplayType.Day); };
+        _weekToggle.Click += (s, e) => { SetSelectedType(CalendarDisplayType.Week); };
+        _monthToggle.Click += (s, e) => { SetSelectedType(CalendarDisplayType.Month); };
+        _yearToggle.Click += (s, e) => { SetSelectedType(CalendarDisplayType.Year); };
+
+        UpdateToggleButtonStates();
+    }
+
+    private void TodayClicked(object sender, RoutedEventArgs e) => TodayClickedCommand?.Execute(null);
+
+    private void SetSelectedType(CalendarDisplayType type)
+    {
+        SelectedType = type;
+        UpdateToggleButtonStates();
+    }
+
+    private void UpdateToggleButtonStates()
+    {
+        _dayToggle.IsChecked = SelectedType == CalendarDisplayType.Day;
+        _weekToggle.IsChecked = SelectedType == CalendarDisplayType.Week;
+        _monthToggle.IsChecked = SelectedType == CalendarDisplayType.Month;
+        _yearToggle.IsChecked = SelectedType == CalendarDisplayType.Year;
+    }
+}

Wino.Calendar/Controls/WinoCalendarView.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Windows.Input;
+using CommunityToolkit.Diagnostics;
+using Windows.UI;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Helpers;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoCalendarView : Control
+{
+    private const string PART_DayViewItemBorder = nameof(PART_DayViewItemBorder);
+    private const string PART_CalendarView = nameof(PART_CalendarView);
+
+    public static readonly DependencyProperty HighlightedDateRangeProperty = DependencyProperty.Register(nameof(HighlightedDateRange), typeof(DateRange), typeof(WinoCalendarView), new PropertyMetadata(null, new PropertyChangedCallback(OnHighlightedDateRangeChanged)));
+    public static readonly DependencyProperty VisibleDateBackgroundProperty = DependencyProperty.Register(nameof(VisibleDateBackground), typeof(Brush), typeof(WinoCalendarView), new PropertyMetadata(null, new PropertyChangedCallback(OnPropertiesChanged)));
+    public static readonly DependencyProperty DateClickedCommandProperty = DependencyProperty.Register(nameof(DateClickedCommand), typeof(ICommand), typeof(WinoCalendarView), new PropertyMetadata(null));
+    public static readonly DependencyProperty TodayBackgroundColorProperty = DependencyProperty.Register(nameof(TodayBackgroundColor), typeof(Color), typeof(WinoCalendarView), new PropertyMetadata(null));
+
+    public Color TodayBackgroundColor
+    {
+        get { return (Color)GetValue(TodayBackgroundColorProperty); }
+        set { SetValue(TodayBackgroundColorProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets or sets the command to execute when a date is picked.
+    /// Unused.
+    /// </summary>
+    public ICommand DateClickedCommand
+    {
+        get { return (ICommand)GetValue(DateClickedCommandProperty); }
+        set { SetValue(DateClickedCommandProperty, value); }
+    }
+
+    /// <summary>
+    /// Gets or sets the highlighted range of dates.
+    /// </summary>
+    public DateRange HighlightedDateRange
+    {
+        get { return (DateRange)GetValue(HighlightedDateRangeProperty); }
+        set { SetValue(HighlightedDateRangeProperty, value); }
+    }
+
+    public Brush VisibleDateBackground
+    {
+        get { return (Brush)GetValue(VisibleDateBackgroundProperty); }
+        set { SetValue(VisibleDateBackgroundProperty, value); }
+    }
+
+
+
+    private CalendarView CalendarView;
+
+    public WinoCalendarView()
+    {
+        DefaultStyleKey = typeof(WinoCalendarView);
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        CalendarView = GetTemplateChild(PART_CalendarView) as CalendarView;
+
+        Guard.IsNotNull(CalendarView, nameof(CalendarView));
+
+        CalendarView.SelectedDatesChanged -= InternalCalendarViewSelectionChanged;
+        CalendarView.SelectedDatesChanged += InternalCalendarViewSelectionChanged;
+
+        // TODO: Should come from settings.
+        CalendarView.FirstDayOfWeek = Windows.Globalization.DayOfWeek.Monday;
+
+        // Everytime display mode changes, update the visible date range backgrounds.
+        // If users go back from year -> month -> day, we need to update the visible date range backgrounds.
+
+        CalendarView.RegisterPropertyChangedCallback(CalendarView.DisplayModeProperty, (s, e) => UpdateVisibleDateRangeBackgrounds());
+    }
+
+    private void InternalCalendarViewSelectionChanged(CalendarView sender, CalendarViewSelectedDatesChangedEventArgs args)
+    {
+        if (args.AddedDates?.Count > 0)
+        {
+            var clickedDate = args.AddedDates[0].Date;
+            SetInnerDisplayDate(clickedDate);
+
+            var clickArgs = new CalendarViewDayClickedEventArgs(clickedDate);
+            DateClickedCommand?.Execute(clickArgs);
+        }
+
+        // Reset selection, we don't show selected dates but react to them.
+        CalendarView.SelectedDates.Clear();
+    }
+
+    private static void OnPropertiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is WinoCalendarView control)
+        {
+            control.UpdateVisibleDateRangeBackgrounds();
+        }
+    }
+
+    private void SetInnerDisplayDate(DateTime dateTime) => CalendarView?.SetDisplayDate(dateTime);
+
+    // Changing selected dates will trigger the selection changed event.
+    // It will behave like user clicked the date.
+    public void GoToDay(DateTime dateTime) => CalendarView.SelectedDates.Add(dateTime);
+
+    private static void OnHighlightedDateRangeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is WinoCalendarView control)
+        {
+            control.SetInnerDisplayDate(control.HighlightedDateRange.StartDate);
+            control.UpdateVisibleDateRangeBackgrounds();
+        }
+    }
+
+    public void UpdateVisibleDateRangeBackgrounds()
+    {
+        if (HighlightedDateRange == null || VisibleDateBackground == null || TodayBackgroundColor == null || CalendarView == null) return;
+
+        var markDateCalendarDayItems = WinoVisualTreeHelper.FindDescendants<CalendarViewDayItem>(CalendarView);
+
+        foreach (var calendarDayItem in markDateCalendarDayItems)
+        {
+            var border = WinoVisualTreeHelper.GetChildObject<Border>(calendarDayItem, PART_DayViewItemBorder);
+
+            if (border == null) return;
+
+            if (calendarDayItem.Date.Date == DateTime.Today.Date)
+            {
+                border.Background = new SolidColorBrush(TodayBackgroundColor);
+            }
+            else if (calendarDayItem.Date.Date >= HighlightedDateRange.StartDate.Date && calendarDayItem.Date.Date < HighlightedDateRange.EndDate.Date)
+            {
+                border.Background = VisibleDateBackground;
+            }
+            else
+            {
+                border.Background = null;
+            }
+        }
+    }
+}

Wino.Calendar/Controls/WinoDayTimelineCanvas.cs

@@ -0,0 +1,277 @@
+using System;
+using System.Diagnostics;
+using Microsoft.Graphics.Canvas.Geometry;
+using Microsoft.Graphics.Canvas.UI.Xaml;
+using Windows.Foundation;
+using Windows.UI.Input;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media;
+using Wino.Calendar.Args;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.Controls;
+
+public partial class WinoDayTimelineCanvas : Control, IDisposable
+{
+    public event EventHandler<TimelineCellSelectedArgs> TimelineCellSelected;
+    public event EventHandler<TimelineCellUnselectedArgs> TimelineCellUnselected;
+
+    private const string PART_InternalCanvas = nameof(PART_InternalCanvas);
+    private CanvasControl Canvas;
+
+    public static readonly DependencyProperty RenderOptionsProperty = DependencyProperty.Register(nameof(RenderOptions), typeof(CalendarRenderOptions), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+    public static readonly DependencyProperty SeperatorColorProperty = DependencyProperty.Register(nameof(SeperatorColor), typeof(SolidColorBrush), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+    public static readonly DependencyProperty HalfHourSeperatorColorProperty = DependencyProperty.Register(nameof(HalfHourSeperatorColor), typeof(SolidColorBrush), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+    public static readonly DependencyProperty SelectedCellBackgroundBrushProperty = DependencyProperty.Register(nameof(SelectedCellBackgroundBrush), typeof(SolidColorBrush), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+    public static readonly DependencyProperty WorkingHourCellBackgroundColorProperty = DependencyProperty.Register(nameof(WorkingHourCellBackgroundColor), typeof(SolidColorBrush), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnRenderingPropertiesChanged)));
+    public static readonly DependencyProperty SelectedDateTimeProperty = DependencyProperty.Register(nameof(SelectedDateTime), typeof(DateTime?), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null, new PropertyChangedCallback(OnSelectedDateTimeChanged)));
+    public static readonly DependencyProperty PositionerUIElementProperty = DependencyProperty.Register(nameof(PositionerUIElement), typeof(UIElement), typeof(WinoDayTimelineCanvas), new PropertyMetadata(null));
+
+    public UIElement PositionerUIElement
+    {
+        get { return (UIElement)GetValue(PositionerUIElementProperty); }
+        set { SetValue(PositionerUIElementProperty, value); }
+    }
+
+    public CalendarRenderOptions RenderOptions
+    {
+        get { return (CalendarRenderOptions)GetValue(RenderOptionsProperty); }
+        set { SetValue(RenderOptionsProperty, value); }
+    }
+
+    public SolidColorBrush HalfHourSeperatorColor
+    {
+        get { return (SolidColorBrush)GetValue(HalfHourSeperatorColorProperty); }
+        set { SetValue(HalfHourSeperatorColorProperty, value); }
+    }
+
+    public SolidColorBrush SeperatorColor
+    {
+        get { return (SolidColorBrush)GetValue(SeperatorColorProperty); }
+        set { SetValue(SeperatorColorProperty, value); }
+    }
+
+    public SolidColorBrush WorkingHourCellBackgroundColor
+    {
+        get { return (SolidColorBrush)GetValue(WorkingHourCellBackgroundColorProperty); }
+        set { SetValue(WorkingHourCellBackgroundColorProperty, value); }
+    }
+
+    public SolidColorBrush SelectedCellBackgroundBrush
+    {
+        get { return (SolidColorBrush)GetValue(SelectedCellBackgroundBrushProperty); }
+        set { SetValue(SelectedCellBackgroundBrushProperty, value); }
+    }
+
+    public DateTime? SelectedDateTime
+    {
+        get { return (DateTime?)GetValue(SelectedDateTimeProperty); }
+        set { SetValue(SelectedDateTimeProperty, value); }
+    }
+
+    protected override void OnApplyTemplate()
+    {
+        base.OnApplyTemplate();
+
+        Canvas = GetTemplateChild(PART_InternalCanvas) as CanvasControl;
+
+        // TODO: These will leak. Dispose them properly when needed.
+        Canvas.Draw += OnCanvasDraw;
+        Canvas.PointerPressed += OnCanvasPointerPressed;
+
+        ForceDraw();
+    }
+
+    private static void OnSelectedDateTimeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is WinoDayTimelineCanvas control)
+        {
+            if (e.OldValue != null && e.NewValue == null)
+            {
+                control.RaiseCellUnselected();
+            }
+
+            control.ForceDraw();
+        }
+    }
+
+    private void RaiseCellUnselected()
+    {
+        TimelineCellUnselected?.Invoke(this, new TimelineCellUnselectedArgs());
+    }
+
+    private void OnCanvasPointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
+    {
+        if (RenderOptions == null) return;
+
+        var hourHeight = RenderOptions.CalendarSettings.HourHeight;
+
+        // When users click to cell we need to find the day, hour and minutes (first 30 minutes or second 30 minutes) that it represents on the timeline.
+
+        PointerPoint positionerRootPoint = e.GetCurrentPoint(PositionerUIElement);
+        PointerPoint canvasPointerPoint = e.GetCurrentPoint(Canvas);
+
+        Point touchPoint = canvasPointerPoint.Position;
+
+        var singleDayWidth = (Canvas.ActualWidth / RenderOptions.TotalDayCount);
+
+        int day = (int)(touchPoint.X / singleDayWidth);
+        int hour = (int)(touchPoint.Y / hourHeight);
+
+        bool isSecondHalf = touchPoint.Y % hourHeight > (hourHeight / 2);
+
+        var diffX = positionerRootPoint.Position.X - touchPoint.X;
+        var diffY = positionerRootPoint.Position.Y - touchPoint.Y;
+
+        var cellStartRelativePositionX = diffX + (day * singleDayWidth);
+        var cellEndRelativePositionX = cellStartRelativePositionX + singleDayWidth;
+
+        var cellStartRelativePositionY = diffY + (hour * hourHeight) + (isSecondHalf ? hourHeight / 2 : 0);
+        var cellEndRelativePositionY = cellStartRelativePositionY + (isSecondHalf ? (hourHeight / 2) : hourHeight);
+
+        var cellSize = new Size(cellEndRelativePositionX - cellStartRelativePositionX, hourHeight / 2);
+        var positionerPoint = new Point(cellStartRelativePositionX, cellStartRelativePositionY);
+
+        var clickedDateTime = RenderOptions.DateRange.StartDate.AddDays(day).AddHours(hour).AddMinutes(isSecondHalf ? 30 : 0);
+
+        // If there is already a selected date, in order to mimic the popup behavior, we need to dismiss the previous selection first.
+        // Next click will be a new selection.
+
+        // Raise the events directly here instead of DP to not lose pointer position.
+        if (clickedDateTime == SelectedDateTime || SelectedDateTime != null)
+        {
+            SelectedDateTime = null;
+        }
+        else
+        {
+            SelectedDateTime = clickedDateTime;
+            TimelineCellSelected?.Invoke(this, new TimelineCellSelectedArgs(clickedDateTime, touchPoint, positionerPoint, cellSize));
+        }
+
+        Debug.WriteLine($"Clicked: {clickedDateTime}");
+    }
+
+    public WinoDayTimelineCanvas()
+    {
+        DefaultStyleKey = typeof(WinoDayTimelineCanvas);
+    }
+
+    private static void OnRenderingPropertiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    {
+        if (d is WinoDayTimelineCanvas control)
+        {
+            control.ForceDraw();
+        }
+    }
+
+    private void ForceDraw() => Canvas?.Invalidate();
+
+    private bool CanDrawTimeline()
+    {
+        return RenderOptions != null
+            && Canvas != null
+            && Canvas.ReadyToDraw
+            && WorkingHourCellBackgroundColor != null
+            && SeperatorColor != null
+            && HalfHourSeperatorColor != null
+            && SelectedCellBackgroundBrush != null;
+    }
+
+    private void OnCanvasDraw(CanvasControl sender, CanvasDrawEventArgs args)
+    {
+        if (!CanDrawTimeline()) return;
+
+        int hours = 24;
+
+        double canvasWidth = Canvas.ActualWidth;
+        double canvasHeight = Canvas.ActualHeight;
+
+        if (canvasWidth == 0 || canvasHeight == 0) return;
+
+        // Calculate the width of each rectangle (1 day column)
+        // Equal distribution of the whole width.
+        double rectWidth = canvasWidth / RenderOptions.TotalDayCount;
+
+        // Calculate the height of each rectangle (1 hour row)
+        double rectHeight = RenderOptions.CalendarSettings.HourHeight;
+
+        // Define stroke and fill colors
+        var strokeColor = SeperatorColor.Color;
+        float strokeThickness = 0.5f;
+
+        for (int day = 0; day < RenderOptions.TotalDayCount; day++)
+        {
+            var currentDay = RenderOptions.DateRange.StartDate.AddDays(day);
+
+            bool isWorkingDay = RenderOptions.CalendarSettings.WorkingDays.Contains(currentDay.DayOfWeek);
+
+            // Loop through each hour (rows)
+            for (int hour = 0; hour < hours; hour++)
+            {
+                var renderTime = TimeSpan.FromHours(hour);
+
+                var representingDateTime = currentDay.AddHours(hour);
+
+                // Calculate the position and size of the rectangle
+                double x = day * rectWidth;
+                double y = hour * rectHeight;
+
+                var rectangle = new Rect(x, y, rectWidth, rectHeight);
+
+                // Draw the rectangle border.
+                // This is the main rectangle.
+                args.DrawingSession.DrawRectangle(rectangle, strokeColor, strokeThickness);
+
+                // Fill another rectangle with the working hour background color
+                // This rectangle must be placed with -1 margin to prevent invisible borders of the main rectangle.
+                if (isWorkingDay && renderTime >= RenderOptions.CalendarSettings.WorkingHourStart && renderTime <= RenderOptions.CalendarSettings.WorkingHourEnd)
+                {
+                    var backgroundRectangle = new Rect(x + 1, y + 1, rectWidth - 1, rectHeight - 1);
+
+                    args.DrawingSession.DrawRectangle(backgroundRectangle, strokeColor, strokeThickness);
+                    args.DrawingSession.FillRectangle(backgroundRectangle, WorkingHourCellBackgroundColor.Color);
+                }
+
+                // Draw a line in the center of the rectangle for representing half hours.
+                double lineY = y + rectHeight / 2;
+
+                args.DrawingSession.DrawLine((float)x, (float)lineY, (float)(x + rectWidth), (float)lineY, HalfHourSeperatorColor.Color, strokeThickness, new CanvasStrokeStyle()
+                {
+                    DashStyle = CanvasDashStyle.Dot
+                });
+            }
+
+            // Draw selected item background color for the date if possible.
+            if (SelectedDateTime != null)
+            {
+                var selectedDateTime = SelectedDateTime.Value;
+                if (selectedDateTime.Date == currentDay.Date)
+                {
+                    var selectionRectHeight = rectHeight / 2;
+                    var selectedY = selectedDateTime.Hour * rectHeight + (selectedDateTime.Minute / 60) * rectHeight;
+
+                    // Second half of the hour is selected.
+                    if (selectedDateTime.TimeOfDay.Minutes == 30)
+                    {
+                        selectedY += rectHeight / 2;
+                    }
+
+                    var selectedRectangle = new Rect(day * rectWidth, selectedY, rectWidth, selectionRectHeight);
+                    args.DrawingSession.FillRectangle(selectedRectangle, SelectedCellBackgroundBrush.Color);
+                }
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        if (Canvas == null) return;
+
+        Canvas.Draw -= OnCanvasDraw;
+        Canvas.PointerPressed -= OnCanvasPointerPressed;
+        Canvas.RemoveFromVisualTree();
+
+        Canvas = null;
+    }
+}

Wino.Calendar/Helpers/CalendarXamlHelpers.cs

@@ -0,0 +1,106 @@
+using System.Linq;
+using System.Text.RegularExpressions;
+using Ical.Net.CalendarComponents;
+using Ical.Net.DataTypes;
+using Windows.UI.Xaml.Controls.Primitives;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Collections;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Helpers;
+
+namespace Wino.Calendar.Helpers;
+
+public static class CalendarXamlHelpers
+{
+    public static CalendarItemViewModel GetFirstAllDayEvent(CalendarEventCollection collection)
+        => (CalendarItemViewModel)collection.AllDayEvents.FirstOrDefault();
+
+    /// <summary>
+    /// Returns full date + duration info in Event Details page details title.
+    /// </summary>
+    public static string GetEventDetailsDateString(CalendarItemViewModel calendarItemViewModel, CalendarSettings settings)
+    {
+        if (calendarItemViewModel == null || settings == null) return string.Empty;
+
+        var start = calendarItemViewModel.Period.Start;
+        var end = calendarItemViewModel.Period.End;
+
+        string timeFormat = settings.DayHeaderDisplayType == DayHeaderDisplayType.TwelveHour ? "h:mm tt" : "HH:mm";
+        string dateFormat = settings.DayHeaderDisplayType == DayHeaderDisplayType.TwelveHour ? "dddd, dd MMMM h:mm tt" : "dddd, dd MMMM HH:mm";
+
+        if (calendarItemViewModel.IsMultiDayEvent)
+        {
+            return $"{start.ToString($"dd MMMM ddd {timeFormat}", settings.CultureInfo)} - {end.ToString($"dd MMMM ddd {timeFormat}", settings.CultureInfo)}";
+        }
+        else
+        {
+            return $"{start.ToString(dateFormat, settings.CultureInfo)} - {end.ToString(timeFormat, settings.CultureInfo)}";
+        }
+    }
+
+    public static string GetRecurrenceString(CalendarItemViewModel calendarItemViewModel)
+    {
+        if (calendarItemViewModel == null || !calendarItemViewModel.IsRecurringChild) return string.Empty;
+
+        // Parse recurrence rules
+        var calendarEvent = new CalendarEvent
+        {
+            Start = new CalDateTime(calendarItemViewModel.StartDate),
+            End = new CalDateTime(calendarItemViewModel.EndDate),
+        };
+
+        var recurrenceLines = Regex.Split(calendarItemViewModel.CalendarItem.Recurrence, Constants.CalendarEventRecurrenceRuleSeperator);
+
+        foreach (var line in recurrenceLines)
+        {
+            calendarEvent.RecurrenceRules.Add(new RecurrencePattern(line));
+        }
+
+        if (calendarEvent.RecurrenceRules == null || !calendarEvent.RecurrenceRules.Any())
+        {
+            return "No recurrence pattern.";
+        }
+
+        var recurrenceRule = calendarEvent.RecurrenceRules.First();
+        var daysOfWeek = string.Join(", ", recurrenceRule.ByDay.Select(day => day.DayOfWeek.ToString()));
+        string timeZone = calendarEvent.DtStart.TzId ?? "UTC";
+
+        return $"Every {daysOfWeek}, effective {calendarEvent.DtStart.Value.ToShortDateString()} " +
+               $"from {calendarEvent.DtStart.Value.ToShortTimeString()} to {calendarEvent.DtEnd.Value.ToShortTimeString()} " +
+               $"{timeZone}.";
+    }
+
+    public static string GetDetailsPopupDurationString(CalendarItemViewModel calendarItemViewModel, CalendarSettings settings)
+    {
+        if (calendarItemViewModel == null || settings == null) return string.Empty;
+
+        // Single event in a day.
+        if (!calendarItemViewModel.IsAllDayEvent && !calendarItemViewModel.IsMultiDayEvent)
+        {
+            return $"{calendarItemViewModel.Period.Start.ToString("d", settings.CultureInfo)} {settings.GetTimeString(calendarItemViewModel.Period.Duration)}";
+        }
+        else if (calendarItemViewModel.IsMultiDayEvent)
+        {
+            return $"{calendarItemViewModel.Period.Start.ToString("d", settings.CultureInfo)} - {calendarItemViewModel.Period.End.ToString("d", settings.CultureInfo)}";
+        }
+        else
+        {
+            // All day event.
+            return $"{calendarItemViewModel.Period.Start.ToString("d", settings.CultureInfo)} ({Translator.CalendarItemAllDay})";
+        }
+    }
+
+    public static PopupPlacementMode GetDesiredPlacementModeForEventsDetailsPopup(
+        CalendarItemViewModel calendarItemViewModel,
+        CalendarDisplayType calendarDisplayType)
+    {
+        if (calendarItemViewModel == null) return PopupPlacementMode.Auto;
+
+        // All and/or multi day events always go to the top of the screen.
+        if (calendarItemViewModel.IsAllDayEvent || calendarItemViewModel.IsMultiDayEvent) return PopupPlacementMode.Bottom;
+
+        return XamlHelpers.GetPlaccementModeForCalendarType(calendarDisplayType);
+    }
+}

Wino.Calendar/MainPage.xaml

@@ -2,13 +2,11 @@
     x:Class="Wino.Calendar.MainPage"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:Wino.Calendar"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="using:Wino.Calendar"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d"
-    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
+    mc:Ignorable="d">
 
-    <Grid>
-
-    </Grid>
+    <Grid />
 </Page>

Wino.Calendar/MainPage.xaml.cs

@@ -15,16 +15,15 @@ using Windows.UI.Xaml.Navigation;
 
 // The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409
 
-namespace Wino.Calendar
+namespace Wino.Calendar;
+
+/// <summary>
+/// An empty page that can be used on its own or navigated to within a Frame.
+/// </summary>
+public sealed partial class MainPage : Page
 {
-    /// <summary>
-    /// An empty page that can be used on its own or navigated to within a Frame.
-    /// </summary>
-    public sealed partial class MainPage : Page
+    public MainPage()
     {
-        public MainPage()
-        {
-            this.InitializeComponent();
-        }
+        this.InitializeComponent();
     }
 }

Wino.Calendar/Models/CalendarItemMeasurement.cs

@@ -0,0 +1,16 @@
+namespace Wino.Calendar.Models;
+
+public struct CalendarItemMeasurement
+{
+    // Where to start?
+    public double Left { get; set; }
+
+    // Extend until where?
+    public double Right { get; set; }
+
+    public CalendarItemMeasurement(double left, double right)
+    {
+        Left = left;
+        Right = right;
+    }
+}

Wino.Calendar/Package.appxmanifest

@@ -3,9 +3,16 @@
 <Package
   xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
   xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
+  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
   xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
   IgnorableNamespaces="uap mp">
 
+  <Identity
+    Name="58272BurakKSE.WinoCalendar"
+    Publisher="CN=51FBDAF3-E212-4149-89A2-A2636B3BC911"
+    Version="1.0.15.0" />
+
 	<!-- Publisher Cache Folders -->
 	<Extensions>
 		<Extension Category="windows.publisherCacheFolders">
@@ -14,13 +21,8 @@
 			</PublisherCacheFolders>
 		</Extension>
 	</Extensions>
-	
-  <Identity
-    Name="58272BurakKSE.WinoCalendar"
-    Publisher="CN=51FBDAF3-E212-4149-89A2-A2636B3BC911"
-    Version="1.0.0.0" />
 
-  <mp:PhoneIdentity PhoneProductId="f047b7dd-96ec-4d54-a862-9321e271e449" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+	<mp:PhoneIdentity PhoneProductId="f047b7dd-96ec-4d54-a862-9321e271e449" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
 
   <Properties>
     <DisplayName>Wino Calendar</DisplayName>
@@ -46,13 +48,31 @@
         Square44x44Logo="Assets\Square44x44Logo.png"
         Description="Wino.Calendar"
         BackgroundColor="transparent">
-        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png"/>
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" Square71x71Logo="Assets\SmallTile.png" Square310x310Logo="Assets\LargeTile.png"/>
         <uap:SplashScreen Image="Assets\SplashScreen.png" />
       </uap:VisualElements>
+
+		<Extensions>
+			<!-- Protocol activation: Google oAuth -->
+			<uap:Extension Category="windows.protocol">
+				<uap:Protocol Name="google.pw.oauth2">
+					<uap:DisplayName>Google Auth Protocol</uap:DisplayName>
+				</uap:Protocol>
+			</uap:Extension>
+
+			<uap5:Extension Category="windows.startupTask">
+				<uap5:StartupTask
+					TaskId="WinoStartupId"
+					Enabled="false"
+					DisplayName="Wino Startup Service" />
+			</uap5:Extension>
+		</Extensions>
     </Application>
   </Applications>
 
   <Capabilities>
-    <Capability Name="internetClient" />
+	  <Capability Name="internetClient" />
+	  <Capability Name="privateNetworkClientServer"/>
+	  <Capability Name="internetClientServer"/>
   </Capabilities>
-</Package>
+</Package>

Wino.Calendar/Properties/AssemblyInfo.cs

@@ -1,29 +0,0 @@
-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.Calendar")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Wino.Calendar")]
-[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.Calendar/Properties/Default.rd.xml

@@ -1,31 +0,0 @@
-<!--
-    This file contains Runtime Directives used by .NET Native. The defaults here are suitable for most
-    developers. However, you can modify these parameters to modify the behavior of the .NET Native
-    optimizer.
-
-    Runtime Directives are documented at https://go.microsoft.com/fwlink/?LinkID=391919
-
-    To fully enable reflection for App1.MyClass and all of its public/private members
-    <Type Name="App1.MyClass" Dynamic="Required All"/>
-
-    To enable dynamic creation of the specific instantiation of AppClass<T> over System.Int32
-    <TypeInstantiation Name="App1.AppClass" Arguments="System.Int32" Activate="Required Public" />
-
-    Using the Namespace directive to apply reflection policy to all the types in a particular namespace
-    <Namespace Name="DataClasses.ViewModels" Serialize="All" />
--->
-
-<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
-  <Application>
-    <!--
-      An Assembly element with Name="*Application*" applies to all assemblies in
-      the application package. The asterisks are not wildcards.
-    -->
-    <Assembly Name="*Application*" Dynamic="Required All" />
-    
-    
-    <!-- Add your application specific runtime directives here. -->
-
-
-  </Application>
-</Directives>