Revert everything back. Mission failed.

Wino.Mail/Activation/ActivationHandler.cs

@@ -0,0 +1,39 @@
+using System.Threading.Tasks;
+
+namespace Wino.Activation
+{
+    // For more information on understanding and extending activation flow see
+    // https://github.com/microsoft/TemplateStudio/blob/main/docs/UWP/activation.md
+    internal abstract class ActivationHandler
+    {
+        public abstract bool CanHandle(object args);
+
+        public abstract Task HandleAsync(object args);
+    }
+
+    // Extend this class to implement new ActivationHandlers
+    internal abstract class ActivationHandler<T> : ActivationHandler
+        where T : class
+    {
+        // Override this method to add the activation logic in your activation handler
+        protected abstract Task HandleInternalAsync(T args);
+
+        public override async Task HandleAsync(object args)
+        {
+            await HandleInternalAsync(args as T);
+        }
+
+        public override bool CanHandle(object args)
+        {
+            // CanHandle checks the args is of type you have configured
+            return args is T && CanHandleInternal(args as T);
+        }
+
+        // You can override this method to add extra validation on activation args
+        // to determine if your ActivationHandler should handle this activation args
+        protected virtual bool CanHandleInternal(T args)
+        {
+            return true;
+        }
+    }
+}

Wino.Mail/Activation/BackgroundActivationHandler.cs

@@ -0,0 +1,154 @@
+using System.Threading.Tasks;
+
+using Serilog;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.Background;
+using Windows.UI.Notifications;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.MailItem;
+using Wino.Core.UWP.Services;
+
+#if NET8_0
+using CommunityToolkit.WinUI.Notifications;
+#else
+using Microsoft.Toolkit.Uwp.Notifications;
+#endif
+
+namespace Wino.Activation
+{
+    internal class BackgroundActivationHandler : ActivationHandler<BackgroundActivatedEventArgs>
+    {
+        private const string BackgroundExecutionLogTag = "[BackgroundExecution] ";
+
+        private readonly IWinoRequestDelegator _winoRequestDelegator;
+        private readonly INativeAppService _nativeAppService;
+        private readonly IWinoRequestProcessor _winoRequestProcessor;
+        private readonly IWinoServerConnectionManager _winoServerConnectionManager;
+        private readonly IMailService _mailService;
+        private ToastArguments _toastArguments;
+
+        BackgroundTaskDeferral _deferral;
+        public BackgroundActivationHandler(IWinoRequestDelegator winoRequestDelegator,
+                                           INativeAppService nativeAppService,
+                                           IWinoRequestProcessor winoRequestProcessor,
+                                           IWinoServerConnectionManager winoServerConnectionManager,
+                                           IMailService mailService)
+        {
+            _winoRequestDelegator = winoRequestDelegator;
+            _nativeAppService = nativeAppService;
+            _winoRequestProcessor = winoRequestProcessor;
+            _winoServerConnectionManager = winoServerConnectionManager;
+            _mailService = mailService;
+        }
+
+        protected override async Task HandleInternalAsync(BackgroundActivatedEventArgs args)
+        {
+            var instance = args.TaskInstance;
+            var taskName = instance.Task.Name;
+
+            instance.Canceled -= OnBackgroundExecutionCanceled;
+            instance.Canceled += OnBackgroundExecutionCanceled;
+
+            _deferral = instance.GetDeferral();
+
+            if (taskName == BackgroundTaskService.ToastActivationTaskEx)
+            {
+                if (instance.TriggerDetails is ToastNotificationActionTriggerDetail toastNotificationActionTriggerDetail)
+                    _toastArguments = ToastArguments.Parse(toastNotificationActionTriggerDetail.Argument);
+
+                // All toast activation mail actions are handled here like mark as read or delete.
+                // This should not launch the application on the foreground.
+
+                // Get the action and mail item id.
+                // Prepare package and send to delegator.
+
+                if (_toastArguments.TryGetValue(Constants.ToastMailItemIdKey, out string mailItemId) &&
+                    _toastArguments.TryGetValue(Constants.ToastActionKey, out MailOperation action) &&
+                    _toastArguments.TryGetValue(Constants.ToastMailItemRemoteFolderIdKey, out string remoteFolderId))
+                {
+                    var mailItem = await _mailService.GetSingleMailItemAsync(mailItemId, remoteFolderId);
+
+                    if (mailItem == null) return;
+
+                    if (_nativeAppService.IsAppRunning())
+                    {
+                        // Just send the package. We should reflect the UI changes as well.
+                        var package = new MailOperationPreperationRequest(action, mailItem);
+
+                        await _winoRequestDelegator.ExecuteAsync(package);
+                    }
+                    else
+                    {
+                        // We need to synchronize changes without reflection the UI changes.
+
+                        // var synchronizer = _winoSynchronizerFactory.GetAccountSynchronizer(mailItem.AssignedAccount.Id);
+                        var prepRequest = new MailOperationPreperationRequest(action, mailItem);
+
+                        var requests = await _winoRequestProcessor.PrepareRequestsAsync(prepRequest);
+
+                        foreach (var request in requests)
+                        {
+                            _winoServerConnectionManager.QueueRequest(request, mailItem.AssignedAccount.Id);
+
+                            // synchronizer.QueueRequest(request);
+                        }
+
+                        //var options = new SynchronizationOptions()
+                        //{
+                        //    Type = SynchronizationType.ExecuteRequests,
+                        //    AccountId = mailItem.AssignedAccount.Id
+                        //};
+
+                        //await synchronizer.SynchronizeAsync(options);
+                    }
+                }
+            }
+
+            instance.Canceled -= OnBackgroundExecutionCanceled;
+
+            _deferral.Complete();
+        }
+
+        private void OnBackgroundExecutionCanceled(Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)
+        {
+            Log.Error($"{BackgroundExecutionLogTag} ({sender.Task.Name}) Background task is canceled. Reason -> {reason}");
+
+            _deferral?.Complete();
+        }
+
+        protected override bool CanHandleInternal(BackgroundActivatedEventArgs args)
+        {
+            var instance = args.TaskInstance;
+            var taskName = instance.Task.Name;
+
+            if (taskName == BackgroundTaskService.ToastActivationTaskEx)
+            {
+                // User clicked Mark as Read or Delete in toast notification.
+                // MailId and Action must present in the arguments.
+
+                return true;
+
+                //if (instance.TriggerDetails is ToastNotificationActionTriggerDetail toastNotificationActionTriggerDetail)
+                //{
+                //    _toastArguments = ToastArguments.Parse(toastNotificationActionTriggerDetail.Argument);
+
+                //    return
+                //        _toastArguments.Contains(Constants.ToastMailItemIdKey) &&
+                //        _toastArguments.Contains(Constants.ToastActionKey);
+                //}
+
+            }
+            else if (taskName == BackgroundTaskService.BackgroundSynchronizationTimerTaskNameEx)
+            {
+                // This is timer based background synchronization.
+
+
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

Wino.Mail/Activation/DefaultActivationHandler.cs

@@ -0,0 +1,30 @@
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Activation;
+using Wino.Views;
+
+#if NET8_0
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Media.Animation;
+#else
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media.Animation;
+#endif
+
+namespace Wino.Activation
+{
+    internal 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.Mail/Activation/FileActivationHandler.cs

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Activation;
+using Windows.Storage;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Services;
+using Wino.Helpers;
+using Wino.Views;
+
+#if NET8_0
+using Microsoft.UI.Xaml.Media.Animation;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+#else
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media.Animation;
+#endif
+
+namespace Wino.Activation
+{
+    internal class FileActivationHandler : ActivationHandler<FileActivatedEventArgs>
+    {
+        private readonly INativeAppService _nativeAppService;
+        private readonly IMimeFileService _mimeFileService;
+        private readonly IStatePersistanceService _statePersistanceService;
+        private readonly IWinoNavigationService _winoNavigationService;
+
+        public FileActivationHandler(INativeAppService nativeAppService,
+                                     IMimeFileService mimeFileService,
+                                     IStatePersistanceService statePersistanceService,
+                                     IWinoNavigationService winoNavigationService)
+        {
+            _nativeAppService = nativeAppService;
+            _mimeFileService = mimeFileService;
+            _statePersistanceService = statePersistanceService;
+            _winoNavigationService = winoNavigationService;
+        }
+
+        protected override async Task HandleInternalAsync(FileActivatedEventArgs args)
+        {
+            // Always handle the last item passed.
+            // Multiple files are not supported.
+
+            var file = args.Files.Last() as StorageFile;
+
+            // Only EML files are supported now.
+            var fileExtension = Path.GetExtension(file.Path);
+
+            if (string.Equals(fileExtension, ".eml", StringComparison.OrdinalIgnoreCase))
+            {
+                var fileBytes = await file.ReadBytesAsync();
+                var directoryName = Path.GetDirectoryName(file.Path);
+
+                var messageInformation = await _mimeFileService.GetMimeMessageInformationAsync(fileBytes, directoryName).ConfigureAwait(false);
+
+                if (_nativeAppService.IsAppRunning())
+                {
+                    // TODO: Activate another Window and go to mail rendering page.
+                    _winoNavigationService.NavigateRendering(messageInformation);
+                }
+                else
+                {
+                    _statePersistanceService.ShouldShiftMailRenderingDesign = true;
+
+                    (Window.Current.Content as Frame).Navigate(typeof(MailRenderingPage), messageInformation, new DrillInNavigationTransitionInfo());
+                }
+            }
+        }
+
+        protected override bool CanHandleInternal(FileActivatedEventArgs args) => args.Files.Any();
+
+    }
+}

Wino.Mail/Activation/ProtocolActivationHandler.cs

@@ -0,0 +1,56 @@
+using System.Threading.Tasks;
+using System.Web;
+using CommunityToolkit.Mvvm.Messaging;
+using Windows.ApplicationModel.Activation;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Messages.Authorization;
+using Wino.Core.Messages.Shell;
+
+namespace Wino.Activation
+{
+    internal class ProtocolActivationHandler : ActivationHandler<ProtocolActivatedEventArgs>
+    {
+        private const string GoogleAuthorizationProtocolTag = "google.pw.oauth2";
+        private const string MailtoProtocolTag = "mailto:";
+
+        private readonly INativeAppService _nativeAppService;
+        private readonly ILaunchProtocolService _launchProtocolService;
+
+        public ProtocolActivationHandler(INativeAppService nativeAppService, ILaunchProtocolService launchProtocolService)
+        {
+            _nativeAppService = nativeAppService;
+            _launchProtocolService = launchProtocolService;
+        }
+
+        protected override Task HandleInternalAsync(ProtocolActivatedEventArgs args)
+        {
+            // Check URI prefix.
+
+            var protocolString = args.Uri.AbsoluteUri;
+
+            // Google OAuth Response
+            if (protocolString.StartsWith(GoogleAuthorizationProtocolTag))
+            {
+                // App must be working already. No need to check for running state.
+                WeakReferenceMessenger.Default.Send(new ProtocolAuthorizationCallbackReceived(args.Uri));
+            }
+            else if (protocolString.StartsWith(MailtoProtocolTag))
+            {
+                // mailto activation. Try to parse params.
+
+                var replaced = protocolString.Replace(MailtoProtocolTag, "mailto=");
+                replaced = Wino.Core.Extensions.StringExtensions.ReplaceFirst(replaced, "?", "&");
+
+                _launchProtocolService.MailtoParameters = HttpUtility.ParseQueryString(replaced);
+
+                if (_nativeAppService.IsAppRunning())
+                {
+                    // Just send publish a message. Shell will continue.
+                    WeakReferenceMessenger.Default.Send(new MailtoProtocolMessageRequested());
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}

Wino.Mail/Activation/ToastNotificationActivationHandler.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.Messaging;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+using Windows.ApplicationModel.Activation;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Messages.Accounts;
+
+#if NET8_0
+using CommunityToolkit.WinUI.Notifications;
+#else
+using Microsoft.Toolkit.Uwp.Notifications;
+#endif
+
+namespace Wino.Activation
+{
+    /// <summary>
+    /// This handler will only handle the toasts that runs on foreground.
+    /// Background executions are not handled here like mark as read or delete.
+    /// </summary>
+    internal class ToastNotificationActivationHandler : ActivationHandler<ToastNotificationActivatedEventArgs>
+    {
+        private readonly INativeAppService _nativeAppService;
+        private readonly IMailService _mailService;
+        private readonly IFolderService _folderService;
+
+        private ToastArguments _toastArguments;
+
+        public ToastNotificationActivationHandler(INativeAppService nativeAppService,
+                                                  IMailService mailService,
+                                                  IFolderService folderService)
+        {
+            _nativeAppService = nativeAppService;
+            _mailService = mailService;
+            _folderService = folderService;
+        }
+
+        protected override async Task HandleInternalAsync(ToastNotificationActivatedEventArgs args)
+        {
+            // Create the mail item navigation event.
+            // If the app is running, it'll be picked up by the Messenger.
+            // Otherwise we'll save it and handle it when the shell loads all accounts.
+
+            // Parse the mail unique id and perform above actions.
+            if (Guid.TryParse(_toastArguments[Constants.ToastMailItemIdKey], out Guid mailItemUniqueId))
+            {
+                var account = await _mailService.GetMailAccountByUniqueIdAsync(mailItemUniqueId).ConfigureAwait(false);
+                if (account == null) return;
+
+                var mailItem = await _mailService.GetSingleMailItemAsync(mailItemUniqueId).ConfigureAwait(false);
+                if (mailItem == null) return;
+
+                var message = new AccountMenuItemExtended(mailItem.AssignedFolder.Id, mailItem);
+
+                // Delegate this event to LaunchProtocolService so app shell can pick it up on launch if app doesn't work.
+                var launchProtocolService = App.Current.Services.GetService<ILaunchProtocolService>();
+                launchProtocolService.LaunchParameter = message;
+
+                // Send the messsage anyways. Launch protocol service will be ignored if the message is picked up by subscriber shell.
+                WeakReferenceMessenger.Default.Send(message);
+            }
+        }
+
+        protected override bool CanHandleInternal(ToastNotificationActivatedEventArgs args)
+        {
+            try
+            {
+                _toastArguments = ToastArguments.Parse(args.Argument);
+
+                return
+                    _toastArguments.Contains(Constants.ToastMailItemIdKey) &&
+                    _toastArguments.Contains(Constants.ToastActionKey);
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Couldn't handle parsing toast notification arguments for foreground navigate.");
+            }
+
+            return false;
+        }
+    }
+}

Wino.Mail/App.xaml

@@ -0,0 +1,234 @@
+<Application
+    x:Class="Wino.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:controls="using:Wino.Controls"
+    xmlns:selectors="using:Wino.Selectors"
+    xmlns:wino="using:Wino">
+
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+
+                <ResourceDictionary Source="/Styles/Converters.xaml" />
+                <ResourceDictionary Source="/Styles/FontIcons.xaml" />
+                <ResourceDictionary Source="/Styles/Colors.xaml" />
+                <ResourceDictionary Source="/Styles/ContentPresenters.xaml" />
+                <ResourceDictionary Source="/Styles/ImagePreviewControl.xaml" />
+                <ResourceDictionary Source="/Styles/CommandBarItems.xaml" />
+                <ResourceDictionary Source="/Styles/ItemContainerStyles.xaml" />
+                <ResourceDictionary Source="/Styles/WinoInfoBar.xaml" />
+
+                <ResourceDictionary>
+
+                    <x:Double x:Key="AppBarButtonContentHeight">19</x:Double>
+                    <x:Double x:Key="NavigationViewItemOnLeftIconBoxHeight">19</x:Double>
+                    <Thickness x:Key="ImapSetupDialogSubPagePadding">24,24,24,24</Thickness>
+
+                    <Style x:Key="PageStyle" TargetType="Page">
+                        <Setter Property="Margin" Value="-1,0,0,0" />
+                        <Setter Property="Padding" Value="12" />
+                        <Setter Property="Background" Value="{ThemeResource AppBarBackgroundColor}" />
+                        <Setter Property="Template">
+                            <Setter.Value>
+                                <ControlTemplate>
+                                    <Grid Padding="12">
+                                        <ContentPresenter />
+                                    </Grid>
+                                </ControlTemplate>
+                            </Setter.Value>
+                        </Setter>
+                    </Style>
+
+                    <!--  Border style for each page's root border for separation of zones.  -->
+                    <Style TargetType="Border" x:Key="PageRootBorderStyle">
+                        <Setter Property="Margin" Value="7,0,7,7" />
+                        <Setter Property="Background" Value="{ThemeResource WinoContentZoneBackgroud}" />
+                        <Setter Property="BorderBrush" Value="{StaticResource CardStrokeColorDefaultBrush}" />
+                        <Setter Property="CornerRadius" Value="7" />
+                        <Setter Property="BorderThickness" Value="1" />
+                    </Style>
+
+                    <!--  Default StackPanel animation.  -->
+                    <Style TargetType="StackPanel">
+                        <Setter Property="ChildrenTransitions">
+                            <Setter.Value>
+                                <TransitionCollection>
+                                    <EntranceThemeTransition IsStaggeringEnabled="True" />
+                                </TransitionCollection>
+                            </Setter.Value>
+                        </Setter>
+                    </Style>
+
+                    <!--  Default Style for ContentDialog  -->
+                    <Style
+                        x:Key="WinoDialogStyle"
+                        BasedOn="{StaticResource DefaultContentDialogStyle}"
+                        TargetType="ContentDialog" />
+
+                    <!--  Settings Menu Item Template  -->
+                    <Style TargetType="controls:SettingsMenuItemControl">
+                        <Setter Property="HorizontalAlignment" Value="Stretch" />
+                        <Setter Property="VerticalAlignment" Value="Stretch" />
+                        <Setter Property="Padding" Value="0" />
+                        <Setter Property="IsClickable" Value="True" />
+                        <Setter Property="Template">
+                            <Setter.Value>
+                                <ControlTemplate TargetType="controls:SettingsMenuItemControl">
+                                    <Grid>
+                                        <Button
+                                            Padding="0"
+                                            HorizontalAlignment="Stretch"
+                                            HorizontalContentAlignment="Stretch"
+                                            Command="{TemplateBinding Command}"
+                                            CommandParameter="{TemplateBinding CommandParameter}"
+                                            IsEnabled="{TemplateBinding IsEnabled}"
+                                            IsHitTestVisible="{TemplateBinding IsClickable}">
+                                            <Grid
+                                                Height="70"
+                                                Padding="0,6,12,6"
+                                                CornerRadius="4">
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="50" />
+                                                    <ColumnDefinition Width="*" />
+                                                </Grid.ColumnDefinitions>
+
+                                                <ContentControl
+                                                    HorizontalAlignment="Center"
+                                                    VerticalAlignment="Center"
+                                                    Content="{TemplateBinding Icon}" />
+
+                                                <Grid
+                                                    Grid.Column="1"
+                                                    Margin="4,0"
+                                                    VerticalAlignment="Center"
+                                                    RowSpacing="3">
+                                                    <Grid.RowDefinitions>
+                                                        <RowDefinition Height="Auto" />
+                                                        <RowDefinition Height="Auto" />
+                                                    </Grid.RowDefinitions>
+
+                                                    <TextBlock
+                                                        VerticalAlignment="Center"
+                                                        FontWeight="SemiBold"
+                                                        Style="{StaticResource BodyTextBlockStyle}"
+                                                        Text="{TemplateBinding Title}" />
+                                                    <TextBlock
+                                                        Grid.Row="1"
+                                                        VerticalAlignment="Center"
+                                                        Style="{StaticResource CaptionTextBlockStyle}"
+                                                        Text="{TemplateBinding Description}" />
+                                                </Grid>
+
+                                                <Viewbox
+                                                    Grid.Column="0"
+                                                    Grid.ColumnSpan="2"
+                                                    Width="16"
+                                                    Height="16"
+                                                    HorizontalAlignment="Right"
+                                                    VerticalAlignment="Center"
+                                                    Visibility="{Binding RelativeSource={RelativeSource Mode=TemplatedParent}, Path=IsNavigateIconVisible}">
+                                                    <PathIcon Data="F1 M 5.029297 19.091797 L 14.111328 10 L 5.029297 0.908203 L 5.908203 0.029297 L 15.888672 10 L 5.908203 19.970703 Z " />
+                                                </Viewbox>
+                                            </Grid>
+                                        </Button>
+
+                                        <ContentControl
+                                            Grid.RowSpan="2"
+                                            Margin="0,0,16,0"
+                                            HorizontalAlignment="Right"
+                                            VerticalAlignment="Center"
+                                            Content="{TemplateBinding SideContent}"
+                                            IsHitTestVisible="True"
+                                            Visibility="{Binding RelativeSource={RelativeSource Mode=TemplatedParent}, Path=IsNavigateIconVisible, Converter={StaticResource ReverseBooleanToVisibilityConverter}}" />
+                                    </Grid>
+                                </ControlTemplate>
+                            </Setter.Value>
+                        </Setter>
+                    </Style>
+
+                    <!--  Wino Navigation View Item  -->
+                    <Style TargetType="controls:WinoNavigationViewItem">
+                        <Setter Property="ContentTransitions">
+                            <Setter.Value>
+                                <TransitionCollection>
+                                    <PopupThemeTransition />
+                                </TransitionCollection>
+                            </Setter.Value>
+                        </Setter>
+                    </Style>
+
+                    <DataTemplate x:Key="NoneTemplate">
+                        <Image Source="/Assets/FileTypes/type_none.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="ExecutableTemplate">
+                        <Image Source="/Assets/FileTypes/type_executable.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="ImageTemplate">
+                        <Image Source="/Assets/FileTypes/type_image.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="VideoTemplate">
+                        <Image Source="/Assets/FileTypes/type_video.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="AudioTemplate">
+                        <Image Source="/Assets/FileTypes/type_audio.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="PDFTemplate">
+                        <Image Source="/Assets/FileTypes/type_pdf.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="HTMLTemplate">
+                        <Image Source="/Assets/FileTypes/type_html.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="RarTemplate">
+                        <Image Source="/Assets/FileTypes/type_rar.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="ArchiveTemplate">
+                        <Image Source="/Assets/FileTypes/type_archive.png" />
+                    </DataTemplate>
+
+                    <DataTemplate x:Key="OtherTemplate">
+                        <Image Source="/Assets/FileTypes/type_other.png" />
+                    </DataTemplate>
+
+                    <selectors:FileAttachmentTypeSelector
+                        x:Key="FileTypeIconSelector"
+                        Archive="{StaticResource ArchiveTemplate}"
+                        Executable="{StaticResource ExecutableTemplate}"
+                        HTML="{StaticResource HTMLTemplate}"
+                        Image="{StaticResource ImageTemplate}"
+                        None="{StaticResource NoneTemplate}"
+                        Other="{StaticResource OtherTemplate}"
+                        PDF="{StaticResource PDFTemplate}"
+                        RarArchive="{StaticResource RarTemplate}"
+                        Video="{StaticResource VideoTemplate}" />
+                </ResourceDictionary>
+
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+
+                <!--  Define Global Styles here  -->
+                <ResourceDictionary>
+                    <Style TargetType="ScrollViewer">
+                        <Setter Property="VerticalScrollBarVisibility" Value="Auto" />
+                    </Style>
+
+                    <!--  Remove border/backgroud of command bar  -->
+                    <SolidColorBrush x:Key="CommandBarBackground" Color="Transparent" />
+                    <SolidColorBrush x:Key="CommandBarBackgroundOpen" Color="Transparent" />
+                    <SolidColorBrush x:Key="CommandBarBorderBrushOpen" Color="Transparent" />
+                    <Thickness x:Key="CommandBarBorderThicknessOpen">0</Thickness>
+                </ResourceDictionary>
+
+                <!--  Last item must always be the default theme.  -->
+                <ResourceDictionary Source="/AppThemes/Mica.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

Wino.Mail/App.xaml.cs

@@ -0,0 +1,226 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AppCenter.Analytics;
+using Microsoft.AppCenter.Crashes;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.AppService;
+using Windows.ApplicationModel.Background;
+using Windows.Storage;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Wino.Activation;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Services;
+using Wino.Core.WinUI.Services;
+
+namespace Wino
+{
+    public sealed partial class App : Application
+    {
+        private BackgroundTaskDeferral backgroundTaskDeferral;
+
+        private readonly IApplicationConfiguration _applicationFolderConfiguration;
+
+        public App()
+        {
+            InitializeComponent();
+
+            UnhandledException += OnAppUnhandledException;
+            EnteredBackground += OnEnteredBackground;
+            LeavingBackground += OnLeavingBackground;
+
+            Resuming += OnResuming;
+            Suspending += OnSuspending;
+
+            Services = ConfigureServices();
+
+            _logInitializer = Services.GetService<ILogInitializer>();
+
+            ConfigureLogger();
+            ConfigureAppCenter();
+            ConfigurePrelaunch();
+            ConfigureXbox();
+
+            _applicationFolderConfiguration = Services.GetService<IApplicationConfiguration>();
+
+            // Make sure the paths are setup on app start.
+            _applicationFolderConfiguration.ApplicationDataFolderPath = ApplicationData.Current.LocalFolder.Path;
+            _applicationFolderConfiguration.PublisherSharedFolderPath = ApplicationData.Current.GetPublisherCacheFolder(ApplicationConfiguration.SharedFolderName).Path;
+
+            _appServiceConnectionManager = Services.GetService<IWinoServerConnectionManager<AppServiceConnection>>();
+            _themeService = Services.GetService<IThemeService>();
+            _databaseService = Services.GetService<IDatabaseService>();
+            _translationService = Services.GetService<ITranslationService>();
+            _appShellService = Services.GetService<IAppShellService>();
+
+            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+        }
+
+        private async void OnResuming(object sender, object e)
+        {
+            // App Service connection was lost on suspension.
+            // We must restore it.
+            // Server might be running already, but re-launching it will trigger a new connection attempt.
+
+            await _appServiceConnectionManager.ConnectAsync();
+        }
+
+        private void OnSuspending(object sender, SuspendingEventArgs e)
+        {
+            var deferral = e.SuspendingOperation.GetDeferral();
+            deferral.Complete();
+        }
+
+        private void LogActivation(string log) => Log.Information($"{WinoLaunchLogPrefix}{log}");
+        private void OnLeavingBackground(object sender, LeavingBackgroundEventArgs e) => LogActivation($"Wino went foreground.");
+        private void OnEnteredBackground(object sender, EnteredBackgroundEventArgs e) => LogActivation($"Wino went background.");
+
+
+        protected override void OnWindowCreated(WindowCreatedEventArgs args)
+        {
+            base.OnWindowCreated(args);
+
+            _appShellService.AppWindow = args.Window;
+
+            LogActivation("Window is created.");
+
+            ConfigureTitleBar();
+        }
+
+        protected override async void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            LogActivation($"OnLaunched -> {args.GetType().Name}, Kind -> {args.Kind}, PreviousExecutionState -> {args.PreviousExecutionState}, IsPrelaunch -> {args.PrelaunchActivated}");
+
+            if (!args.PrelaunchActivated)
+            {
+                await ActivateWinoAsync(args);
+            }
+        }
+
+        protected override async void OnFileActivated(FileActivatedEventArgs args)
+        {
+            base.OnFileActivated(args);
+
+            Log.Information($"File activation for {args.Files.Count} item(s).");
+
+            await ActivateWinoAsync(args);
+        }
+
+        protected override async void OnActivated(IActivatedEventArgs args)
+        {
+            base.OnActivated(args);
+
+            Log.Information($"OnActivated -> {args.GetType().Name}, Kind -> {args.Kind}, Prev Execution State -> {args.PreviousExecutionState}");
+
+            await ActivateWinoAsync(args);
+        }
+
+        protected override async void OnBackgroundActivated(BackgroundActivatedEventArgs args)
+        {
+            base.OnBackgroundActivated(args);
+
+            // This can only be handled in App.xaml.cs
+            // Using handler activation makes it crash at runtime with a COM error...
+            if (args.TaskInstance.TriggerDetails is AppServiceTriggerDetails appServiceTriggerDetails)
+            {
+                // Only accept connections from callers in the same package
+                if (appServiceTriggerDetails.CallerPackageFamilyName == Package.Current.Id.FamilyName)
+                {
+                    // Connection established from the fulltrust process
+
+                    backgroundTaskDeferral = args.TaskInstance.GetDeferral();
+                    args.TaskInstance.Canceled += OnBackgroundTaskCanceled;
+
+                    _appServiceConnectionManager.Connection = appServiceTriggerDetails.AppServiceConnection;
+                }
+            }
+
+            LogActivation($"OnBackgroundActivated -> {args.GetType().Name}, TaskInstanceIdName -> {args.TaskInstance?.Task?.Name ?? "NA"}");
+
+            await ActivateWinoAsync(args);
+        }
+
+        private void OnAppUnhandledException(object sender, Windows.UI.Xaml.UnhandledExceptionEventArgs e)
+        {
+            var parameters = new Dictionary<string, string>()
+            {
+                { "BaseMessage", e.Exception.GetBaseException().Message },
+                { "BaseStackTrace", e.Exception.GetBaseException().StackTrace },
+                { "StackTrace", e.Exception.StackTrace },
+                { "Message", e.Exception.Message },
+            };
+
+            Log.Error(e.Exception, "[Wino Crash]");
+
+            Crashes.TrackError(e.Exception, parameters);
+            Analytics.TrackEvent("Wino Crashed", parameters);
+        }
+
+        private bool IsInteractiveLaunchArgs(object args) => args is IActivatedEventArgs;
+
+        private async Task ActivateWinoAsync(object args)
+        {
+            foreach (var service in initializeServices)
+            {
+                await service.InitializeAsync();
+            }
+
+            if (IsInteractiveLaunchArgs(args))
+            {
+                if (Window.Current.Content == null)
+                {
+                    var mainFrame = new Frame();
+
+                    Window.Current.Content = mainFrame;
+
+                    await _themeService.InitializeAsync();
+                }
+            }
+
+            await HandleActivationAsync(args);
+
+            if (IsInteractiveLaunchArgs(args))
+            {
+                Window.Current.Activate();
+
+                LogActivation("Window activated");
+            }
+        }
+
+        private async Task HandleActivationAsync(object activationArgs)
+        {
+            var activationHandler = GetActivationHandlers().FirstOrDefault(h => h.CanHandle(activationArgs));
+
+            if (activationHandler != null)
+            {
+                await activationHandler.HandleAsync(activationArgs);
+            }
+
+            if (IsInteractiveLaunchArgs(activationArgs))
+            {
+                var defaultHandler = new DefaultActivationHandler();
+                if (defaultHandler.CanHandle(activationArgs))
+                {
+                    await defaultHandler.HandleAsync(activationArgs);
+                }
+            }
+        }
+
+        public async void OnBackgroundTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
+        {
+            Log.Information($"Background task {sender.Task.Name} was canceled. Reason: {reason}");
+
+            await _appServiceConnectionManager.DisconnectAsync();
+
+            backgroundTaskDeferral?.Complete();
+            backgroundTaskDeferral = null;
+
+            _appServiceConnectionManager.Connection = null;
+        }
+    }
+}

Wino.Mail/AppShell.xaml.cs

@@ -0,0 +1,338 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Windows.ApplicationModel.Core;
+using Windows.Foundation;
+
+using Wino.Controls;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Folders;
+using Wino.Core.Domain.Models.MailItem;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Messages.Accounts;
+using Wino.Core.Messages.Mails;
+using Wino.Core.Messages.Shell;
+using Wino.Extensions;
+using Wino.Mail.ViewModels.Data;
+using Wino.MenuFlyouts;
+using Wino.MenuFlyouts.Context;
+using Wino.Views.Abstract;
+using Microsoft.UI.Xaml.Controls;
+
+
+#if NET8_0
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls.Primitives;
+using Microsoft.UI.Xaml.Input;
+using Microsoft.UI.Xaml.Navigation;
+#else
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Controls.Primitives;
+using Windows.UI.Xaml.Input;
+using Windows.UI.Xaml.Navigation;
+using Microsoft.Extensions.DependencyInjection;
+#endif
+
+namespace Wino.Views
+{
+    public sealed partial class AppShell : AppShellAbstract,
+        IRecipient<AccountMenuItemExtended>,
+        IRecipient<NavigateMailFolderEvent>,
+        IRecipient<CreateNewMailWithMultipleAccountsRequested>,
+        IRecipient<InfoBarMessageRequested>,
+        IRecipient<ApplicationThemeChanged>
+    {
+        public AppShell() : base()
+        {
+            InitializeComponent();
+#if !NET8_0
+            // BackdropMaterial is not available in WinUI 3.0.
+            // We manually apply it for UWP version only.
+            SetupMica();
+
+            var coreTitleBar = CoreApplication.GetCurrentView().TitleBar;
+            coreTitleBar.LayoutMetricsChanged += TitleBarLayoutUpdated;
+#endif
+        }
+
+        private void TitleBarLayoutUpdated(CoreApplicationViewTitleBar sender, object args) => UpdateTitleBarLayout(sender);
+
+        private void UpdateTitleBarLayout(CoreApplicationViewTitleBar coreTitleBar) => RealAppBar.SystemReserved = coreTitleBar.SystemOverlayRightInset;
+
+        private async void ItemDroppedOnFolder(object sender, DragEventArgs e)
+        {
+            // Validate package content.
+            if (sender is WinoNavigationViewItem droppedContainer)
+            {
+                droppedContainer.IsDraggingItemOver = false;
+
+                if (CanContinueDragDrop(droppedContainer, e))
+                {
+                    if (droppedContainer.DataContext is IBaseFolderMenuItem draggingFolder)
+                    {
+                        var mailCopies = new List<MailCopy>();
+
+                        var dragPackage = e.DataView.Properties[nameof(MailDragPackage)] as MailDragPackage;
+                        e.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Move;
+
+                        // Extract mail copies from IMailItem.
+                        // ThreadViewModels will be divided into pieces.
+
+                        foreach (var item in dragPackage.DraggingMails)
+                        {
+                            if (item is MailItemViewModel singleMailItemViewModel)
+                            {
+                                mailCopies.Add(singleMailItemViewModel.MailCopy);
+                            }
+                            else if (item is ThreadMailItemViewModel threadViewModel)
+                            {
+                                mailCopies.AddRange(threadViewModel.GetMailCopies());
+                            }
+                        }
+
+                        await ViewModel.PerformMoveOperationAsync(mailCopies, draggingFolder);
+                    }
+                }
+            }
+        }
+
+        private void ItemDragLeaveFromFolder(object sender, DragEventArgs e)
+        {
+            if (sender is WinoNavigationViewItem leavingContainer)
+            {
+                leavingContainer.IsDraggingItemOver = false;
+            }
+        }
+
+        private bool CanContinueDragDrop(WinoNavigationViewItem interactingContainer, DragEventArgs args)
+        {
+            // TODO: Maybe override caption with some information why the validation failed?
+            // Note: Caption has a max length. It may be trimmed in some languages.
+
+            if (interactingContainer == null || !args.DataView.Properties.ContainsKey(nameof(MailDragPackage))) return false;
+
+            var dragPackage = args.DataView.Properties[nameof(MailDragPackage)] as MailDragPackage;
+
+            // Invalid package.
+            if (!dragPackage.DraggingMails.Any()) return false;
+
+            // Check whether source and target folder are the same.
+            if (interactingContainer.IsSelected) return false;
+
+            // Check if the interacting container is a folder.
+            if (!(interactingContainer.DataContext is IBaseFolderMenuItem folderMenuItem)) return false;
+
+            // Check if the folder is a move target.
+            if (!folderMenuItem.IsMoveTarget) return false;
+
+            // Check whether the moving item's account has at least one same as the target folder's account.
+            var draggedAccountIds = folderMenuItem.HandlingFolders.Select(a => a.MailAccountId);
+
+            if (!dragPackage.DraggingMails.Any(a => draggedAccountIds.Contains(a.AssignedAccount.Id))) return false;
+
+            return true;
+        }
+
+        private void ItemDragEnterOnFolder(object sender, DragEventArgs e)
+        {
+            // Validate package content.
+            if (sender is WinoNavigationViewItem droppedContainer && CanContinueDragDrop(droppedContainer, e))
+            {
+                droppedContainer.IsDraggingItemOver = true;
+
+                var draggingFolder = droppedContainer.DataContext as IBaseFolderMenuItem;
+
+                e.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Move;
+                e.DragUIOverride.Caption = string.Format(Translator.DragMoveToFolderCaption, draggingFolder.FolderName);
+            }
+        }
+
+        public async void Receive(AccountMenuItemExtended message)
+        {
+            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async () =>
+            {
+                if (message.FolderId == default) return;
+
+                if (ViewModel.MenuItems.TryGetFolderMenuItem(message.FolderId, out IBaseFolderMenuItem foundMenuItem))
+                {
+                    if (foundMenuItem == null) return;
+
+                    foundMenuItem.Expand();
+
+                    await ViewModel.NavigateFolderAsync(foundMenuItem);
+
+                    navigationView.SelectedItem = foundMenuItem;
+
+                    if (message.NavigateMailItem == null) return;
+
+                    // At this point folder is navigated and items are loaded.
+                    WeakReferenceMessenger.Default.Send(new MailItemNavigationRequested(message.NavigateMailItem.UniqueId));
+                }
+            });
+        }
+
+        private async void MenuSelectionChanged(Microsoft.UI.Xaml.Controls.NavigationView sender, Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)
+        {
+            if (args.SelectedItem is IMenuItem invokedMenuItem)
+            {
+                await ViewModel.MenuItemInvokedOrSelectedAsync(invokedMenuItem);
+            }
+        }
+
+        private async void NavigationViewItemInvoked(Microsoft.UI.Xaml.Controls.NavigationView sender, Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)
+        {
+            // SelectsOnInvoked is handled in MenuSelectionChanged.
+            // This part is only for the items that are not selectable.
+            if (args.InvokedItemContainer is WinoNavigationViewItem winoNavigationViewItem)
+            {
+                if (winoNavigationViewItem.SelectsOnInvoked) return;
+
+                await ViewModel.MenuItemInvokedOrSelectedAsync(winoNavigationViewItem.DataContext as IMenuItem);
+            }
+        }
+
+        public void Receive(NavigateMailFolderEvent message)
+        {
+            if (message.BaseFolderMenuItem == null) return;
+
+            if (navigationView.SelectedItem != message.BaseFolderMenuItem)
+            {
+                var navigateFolderArgs = new NavigateMailFolderEventArgs(message.BaseFolderMenuItem, message.FolderInitLoadAwaitTask);
+
+                ViewModel.NavigationService.NavigateFolder(navigateFolderArgs);
+
+                // Prevent double navigation.
+                navigationView.SelectionChanged -= MenuSelectionChanged;
+                navigationView.SelectedItem = message.BaseFolderMenuItem;
+                navigationView.SelectionChanged += MenuSelectionChanged;
+            }
+            else
+            {
+                // Complete the init task since we are already on the right page.
+                message.FolderInitLoadAwaitTask?.TrySetResult(true);
+            }
+        }
+
+        private void ShellFrameContentNavigated(object sender, NavigationEventArgs e)
+            => RealAppBar.ShellFrameContent = (e.Content as BasePage).ShellContent;
+
+        private void BackButtonClicked(Controls.Advanced.WinoAppTitleBar sender, RoutedEventArgs args)
+        {
+            WeakReferenceMessenger.Default.Send(new ClearMailSelectionsRequested());
+            WeakReferenceMessenger.Default.Send(new DisposeRenderingFrameRequested());
+            WeakReferenceMessenger.Default.Send(new ShellStateUpdated());
+
+        }
+
+        private async void MenuItemContextRequested(UIElement sender, ContextRequestedEventArgs args)
+        {
+            // Delegate this request to ViewModel.
+            // VM will prepare available actions for this folder and show Menu Flyout.
+
+            if (sender is WinoNavigationViewItem menuItem &&
+                menuItem.DataContext is IBaseFolderMenuItem baseFolderMenuItem &&
+                baseFolderMenuItem.IsMoveTarget &&
+                args.TryGetPosition(sender, out Point p))
+            {
+                args.Handled = true;
+
+                var source = new TaskCompletionSource<FolderOperationMenuItem>();
+
+                var actions = ViewModel.GetFolderContextMenuActions(baseFolderMenuItem);
+                var flyout = new FolderOperationFlyout(actions, source);
+
+                flyout.ShowAt(menuItem, new FlyoutShowOptions()
+                {
+                    ShowMode = FlyoutShowMode.Standard,
+                    Position = new Point(p.X + 30, p.Y - 20)
+                });
+
+                var operation = await source.Task;
+
+                flyout.Dispose();
+
+                // No action selected.
+                if (operation == null) return;
+
+                await ViewModel.PerformFolderOperationAsync(operation.Operation, baseFolderMenuItem);
+            }
+        }
+
+        public void Receive(CreateNewMailWithMultipleAccountsRequested message)
+        {
+            // Find the NewMail menu item container.
+
+            var container = navigationView.ContainerFromMenuItem(ViewModel.CreateMailMenuItem);
+
+            var flyout = new AccountSelectorFlyout(message.AllAccounts, ViewModel.CreateNewMailForAsync);
+
+            flyout.ShowAt(container, new FlyoutShowOptions()
+            {
+                ShowMode = FlyoutShowMode.Auto,
+                Placement = FlyoutPlacementMode.Right
+            });
+        }
+
+        private void NavigationPaneOpening(Microsoft.UI.Xaml.Controls.NavigationView sender, object args)
+        {
+            // It's annoying that NavigationView doesn't respect expansion state of the items in Minimal display mode.
+            // Expanded items are collaped, and users need to expand them again.
+            // Regardless of the reason, we will expand the selected item if it's a folder with parent account for visibility.
+
+            if (sender.DisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Minimal && sender.SelectedItem is IFolderMenuItem selectedFolderMenuItem)
+            {
+                selectedFolderMenuItem.Expand();
+            }
+        }
+
+        /// <summary>
+        /// InfoBar message is requested.
+        /// </summary>
+        public async void Receive(InfoBarMessageRequested message)
+        {
+            await ViewModel.ExecuteUIThread(() =>
+            {
+                if (string.IsNullOrEmpty(message.ActionButtonTitle) || message.Action == null)
+                {
+                    ShellInfoBar.ActionButton = null;
+                }
+                else
+                {
+                    ShellInfoBar.ActionButton = new Button()
+                    {
+                        Content = message.ActionButtonTitle,
+                        Command = new RelayCommand(message.Action)
+                    };
+                }
+
+                ShellInfoBar.Message = message.Message;
+                ShellInfoBar.Title = message.Title;
+                ShellInfoBar.Severity = message.Severity.AsMUXCInfoBarSeverity();
+                ShellInfoBar.IsOpen = true;
+            });
+        }
+
+
+        private void SetupMica()
+        {
+#if !NET8_0
+            var resourceManager = App.Current.Services.GetService<IApplicationResourceManager<ResourceDictionary>>();
+
+            if (resourceManager.ContainsResourceKey("UseMica"))
+            {
+                bool isMicaEnabled = resourceManager.GetResource<bool>("UseMica");
+
+                BackdropMaterial.SetApplyToRootOrPageBackground(this, isMicaEnabled);
+            }
+#endif
+        }
+
+        public void Receive(ApplicationThemeChanged message) => SetupMica();
+    }
+}

Wino.Mail/AppThemes/Acrylic.xaml

@@ -0,0 +1,37 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:Microsoft.UI.Xaml.Media"
+    xmlns:xaml="using:Windows.UI.Xaml">
+
+    <x:String x:Key="ThemeName">Acrylic</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <!--  Acrylic Template  -->
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Reading Page Date/Name Group Header Background  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#ecf0f1</SolidColorBrush>
+
+            <local:AcrylicBrush
+                x:Key="WinoApplicationBackgroundColor"
+                BackgroundSource="HostBackdrop"
+                FallbackColor="#F9F9F9"
+                TintColor="#FCFCFC"
+                TintOpacity="0.75" />
+        </ResourceDictionary>
+
+        <ResourceDictionary x:Name="Dark">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#2C2C2C</SolidColorBrush>
+
+            <local:AcrylicBrush
+                x:Key="WinoApplicationBackgroundColor"
+                BackgroundSource="HostBackdrop"
+                FallbackColor="#2C2C2C"
+                TintColor="#2C2C2C"
+                TintOpacity="0.30" />
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Clouds.xaml

@@ -0,0 +1,18 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">Clouds</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/Clouds.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush x:Key="WinoApplicationBackgroundColor" ImageSource="{StaticResource ThemeBackgroundImage}" />
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#b2dffc</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#b2dffc</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Custom.xaml

@@ -0,0 +1,47 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:xaml="using:Windows.UI.Xaml">
+
+    <x:String x:Key="ThemeName">Custom</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appdata:///local/CustomWallpaper.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush
+        x:Key="WinoApplicationBackgroundColor"
+        ImageSource="{StaticResource ThemeBackgroundImage}"
+        Stretch="UniformToFill" />
+
+    <!--  Navigation View Settings  -->
+    <xaml:CornerRadius x:Key="NavigationViewContentGridCornerRadius">0,0,0,0</xaml:CornerRadius>
+    <xaml:CornerRadius x:Key="OverlayCornerRadius">0,1,0,0</xaml:CornerRadius>
+    <Thickness x:Key="NavigationViewContentMargin">0,0,0,0</Thickness>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Reading Page Date/Name Group Header Background  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#ecf0f1</SolidColorBrush>
+
+            <Color x:Key="MainCustomThemeColor">#D9FFFFFF</Color>
+
+            <SolidColorBrush x:Key="AppBarBackgroundColor" Color="{StaticResource MainCustomThemeColor}" />
+            <SolidColorBrush x:Key="NavigationViewContentBackground" Color="Transparent" />
+            <SolidColorBrush x:Key="NavigationViewExpandedPaneBackground" Color="{StaticResource MainCustomThemeColor}" />
+            <SolidColorBrush x:Key="NavigationViewDefaultPaneBackground" Color="{StaticResource MainCustomThemeColor}" />
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <!--  Reading Page Date/Name Group Header Background  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#1f1f1f</SolidColorBrush>
+
+            <Color x:Key="MainCustomThemeColor">#E61F1F1F</Color>
+
+            <!--  Reading Pane Background  -->
+            <SolidColorBrush x:Key="ReadingPaneBackgroundColorBrush" Color="{StaticResource MainCustomThemeColor}" />
+
+            <SolidColorBrush x:Key="AppBarBackgroundColor" Color="{StaticResource MainCustomThemeColor}" />
+            <SolidColorBrush x:Key="NavigationViewContentBackground" Color="Transparent" />
+            <SolidColorBrush x:Key="NavigationViewExpandedPaneBackground" Color="{StaticResource MainCustomThemeColor}" />
+            <SolidColorBrush x:Key="NavigationViewDefaultPaneBackground" Color="{StaticResource MainCustomThemeColor}" />
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Forest.xaml

@@ -0,0 +1,21 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:xaml="using:Windows.UI.Xaml">
+
+    <x:String x:Key="ThemeName">Forest</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/Forest.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush x:Key="WinoApplicationBackgroundColor" ImageSource="{StaticResource ThemeBackgroundImage}" />
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#A800D608</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#59001C01</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Garden.xaml

@@ -0,0 +1,18 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">Garden</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/Garden.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush x:Key="WinoApplicationBackgroundColor" ImageSource="{StaticResource ThemeBackgroundImage}" />
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#dcfad8</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#dcfad8</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Mica.xaml

@@ -0,0 +1,19 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">Mica</x:String>
+    <x:Boolean x:Key="UseMica">True</x:Boolean>
+
+    <SolidColorBrush x:Key="WinoApplicationBackgroundColor">Transparent</SolidColorBrush>
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <!--  Mica Template  -->
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Reading Page Date/Name Group Header Background  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#ecf0f1</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#1f1f1f</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Nighty.xaml

@@ -0,0 +1,20 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">Nighty</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/Nighty.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush x:Key="WinoApplicationBackgroundColor" ImageSource="{StaticResource ThemeBackgroundImage}" />
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Brushes  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#fdcb6e</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <!--  Brushes  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#5413191F</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/Snowflake.xaml

@@ -0,0 +1,20 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">Snowflake</x:String>
+    <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/Snowflake.jpg</x:String>
+    <x:Boolean x:Key="UseMica">False</x:Boolean>
+
+    <ImageBrush x:Key="WinoApplicationBackgroundColor" ImageSource="{StaticResource ThemeBackgroundImage}" />
+    <SolidColorBrush x:Key="AppBarBackgroundColor">Transparent</SolidColorBrush>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Brushes  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#b0c6dd</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <!--  Brushes  -->
+            <SolidColorBrush x:Key="MailListHeaderBackgroundColor">#b0c6dd</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/AppThemes/TestTheme.xaml

@@ -0,0 +1,22 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+    <x:String x:Key="ThemeName">TestTheme.xaml</x:String>
+
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Name="Light">
+            <!--  Background Image  -->
+            <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/bg6.jpg</x:String>
+            <SolidColorBrush x:Key="ShellTitleBarBackgroundColorBrush">#A3FFFFFF</SolidColorBrush>
+            <SolidColorBrush x:Key="ShellNavigationViewBackgroundColorBrush">#A3FFFFFF</SolidColorBrush>
+            <SolidColorBrush x:Key="ReadingPaneBackgroundColorBrush">#fdcb6e</SolidColorBrush>
+        </ResourceDictionary>
+        <ResourceDictionary x:Name="Dark">
+            <!--  Background Image  -->
+            <x:String x:Key="ThemeBackgroundImage">ms-appx:///BackgroundImages/bg6.jpg</x:String>
+
+            <SolidColorBrush x:Key="ShellTitleBarBackgroundColorBrush">#A3000000</SolidColorBrush>
+            <SolidColorBrush x:Key="ShellNavigationViewBackgroundColorBrush">#A3000000</SolidColorBrush>
+            <SolidColorBrush x:Key="ReadingPaneBackgroundColorBrush">#A3262626</SolidColorBrush>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
+</ResourceDictionary>

Wino.Mail/Assets/ReleaseNotes/176.md

@@ -0,0 +1,33 @@
+# 🚀 Welcome to Wino Mail 1.7.6
+
+This version brings bunch of UI improvements and bugfixes on top of the added features thanks to our community members.
+
+## Separated UI Zones
+
+Community liked the proposed designs for separated UI parts and it's implemented now thanks to [Tiktack](https://github.com/Tiktack)
+
+![Separated UI Zones](https://www.winomail.app/images/separatedzones.png)
+
+## Including Conversation History for Replies and Forwards
+
+Previously when you replied to an e-mail conversation history was not included into new draft. This was a limitation due to Quill editor we use as a composer editor but now thanks to [Tiktack](https://github.com/Tiktack) Wino now uses Jodit editor as a composer. It's able to render HTML as it is better.
+
+## HTML Signatures
+
+You can now copy your signature as HTML and paste directly into signature editor. This was asked by community and now is possible with the new Jodit composer.
+
+## Reworked Menu System
+
+Merged accounts will not list individual accounts below instead of inside the More folder menu item.
+
+## New IMAP and Gmail Folder Synchronization
+
+IMAP and Gmail folder synchronization mechanism is reworked. New code works faster and fixed couple parent-child relation issues with the folder. I hope this will also resolve a lot of people complaining some Gmail folders are not visible for them after the initial sync.
+
+## New Languages
+
+Thanks to our amazing community members Wino has more languages supported in this version with the help of Crowdin contributors.
+
+![Crowdin Contributors](https://www.winomail.app/images/contributors.png)
+
+Some of the translations are not completed yet, and Wino will fallback to English strings in case of the translation has not been translated yet.