Revert "File scoped namespaces"

This reverts commit d31d8f574e.
2025-02-16 11:43:30 +01:00
parent d31d8f574e
commit cf9869b71e
617 changed files with 32097 additions and 31478 deletions
--- a/Wino.Core.UWP/Controls/AccountCreationDialogControl.xaml.cs
+++ b/Wino.Core.UWP/Controls/AccountCreationDialogControl.xaml.cs
@@ -9,67 +9,68 @@ using Wino.Core.Domain.Interfaces;
 using Wino.Messaging.UI;


-namespace Wino.Core.UWP.Controls;
-
-public sealed partial class AccountCreationDialogControl : UserControl, IRecipient<CopyAuthURLRequested>
+namespace Wino.Core.UWP.Controls
 {
-    private string copyClipboardURL;
-
-    public event EventHandler CancelClicked;
-
-    public AccountCreationDialogState State
+    public sealed partial class AccountCreationDialogControl : UserControl, IRecipient<CopyAuthURLRequested>
    {
-        get { return (AccountCreationDialogState)GetValue(StateProperty); }
-        set { SetValue(StateProperty, value); }
-    }
+        private string copyClipboardURL;

-    public static readonly DependencyProperty StateProperty = DependencyProperty.Register(nameof(State), typeof(AccountCreationDialogState), typeof(AccountCreationDialogControl), new PropertyMetadata(AccountCreationDialogState.Idle, new PropertyChangedCallback(OnStateChanged)));
+        public event EventHandler CancelClicked;

-    public AccountCreationDialogControl()
-    {
-        InitializeComponent();
-    }
-
-    private static void OnStateChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is AccountCreationDialogControl dialog)
+        public AccountCreationDialogState State
        {
-            dialog.UpdateVisualStates();
+            get { return (AccountCreationDialogState)GetValue(StateProperty); }
+            set { SetValue(StateProperty, value); }
        }
-    }

-    private void UpdateVisualStates() => VisualStateManager.GoToState(this, State.ToString(), false);
+        public static readonly DependencyProperty StateProperty = DependencyProperty.Register(nameof(State), typeof(AccountCreationDialogState), typeof(AccountCreationDialogControl), new PropertyMetadata(AccountCreationDialogState.Idle, new PropertyChangedCallback(OnStateChanged)));

-    public async void Receive(CopyAuthURLRequested message)
-    {
-        copyClipboardURL = message.AuthURL;
-
-        await Task.Delay(2000);
-
-        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
+        public AccountCreationDialogControl()
        {
-            AuthHelpDialogButton.Visibility = Windows.UI.Xaml.Visibility.Visible;
-        });
+            InitializeComponent();
+        }
+
+        private static void OnStateChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is AccountCreationDialogControl dialog)
+            {
+                dialog.UpdateVisualStates();
+            }
+        }
+
+        private void UpdateVisualStates() => VisualStateManager.GoToState(this, State.ToString(), false);
+
+        public async void Receive(CopyAuthURLRequested message)
+        {
+            copyClipboardURL = message.AuthURL;
+
+            await Task.Delay(2000);
+
+            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
+            {
+                AuthHelpDialogButton.Visibility = Windows.UI.Xaml.Visibility.Visible;
+            });
+        }
+
+        private void ControlLoaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
+        {
+            WeakReferenceMessenger.Default.Register(this);
+        }
+
+        private void ControlUnloaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
+        {
+            WeakReferenceMessenger.Default.UnregisterAll(this);
+        }
+
+        private async void CopyClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e)
+        {
+            if (string.IsNullOrEmpty(copyClipboardURL)) return;
+
+            var clipboardService = WinoApplication.Current.Services.GetService<IClipboardService>();
+            await clipboardService.CopyClipboardAsync(copyClipboardURL);
+        }
+
+
+        private void CancelButtonClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e) => CancelClicked?.Invoke(this, null);
    }
-
-    private void ControlLoaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
-    {
-        WeakReferenceMessenger.Default.Register(this);
-    }
-
-    private void ControlUnloaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
-    {
-        WeakReferenceMessenger.Default.UnregisterAll(this);
-    }
-
-    private async void CopyClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e)
-    {
-        if (string.IsNullOrEmpty(copyClipboardURL)) return;
-
-        var clipboardService = WinoApplication.Current.Services.GetService<IClipboardService>();
-        await clipboardService.CopyClipboardAsync(copyClipboardURL);
-    }
-
-
-    private void CancelButtonClicked(object sender, Windows.UI.Xaml.RoutedEventArgs e) => CancelClicked?.Invoke(this, null);
 }
--- a/Wino.Core.UWP/Controls/ControlConstants.cs
+++ b/Wino.Core.UWP/Controls/ControlConstants.cs
@@ -1,105 +1,106 @@
 using System.Collections.Generic;

-namespace Wino.Core.UWP.Controls;
-
-public static class ControlConstants
+namespace Wino.Core.UWP.Controls
 {
-    public static Dictionary<WinoIconGlyph, string> WinoIconFontDictionary = new Dictionary<WinoIconGlyph, string>()
+    public static class ControlConstants
    {
-        { WinoIconGlyph.None, "\u0020" },
-        { WinoIconGlyph.Archive, "\uE066" },
-        { WinoIconGlyph.UnArchive, "\uE06C" },
-        { WinoIconGlyph.Reply, "\uF176" },
-        { WinoIconGlyph.ReplyAll, "\uF17A" },
-        { WinoIconGlyph.Sync, "\uE895" },
-        { WinoIconGlyph.Send, "\uEA8E" },
-        { WinoIconGlyph.LightEditor, "\uE1F6" },
-        { WinoIconGlyph.Delete, "\uEEA6" },
-        { WinoIconGlyph.DarkEditor, "\uEE44" },
-        { WinoIconGlyph.Draft, "\uF3BE" },
-        { WinoIconGlyph.Flag, "\uF40C" },
-        { WinoIconGlyph.ClearFlag, "\uF40F" },
-        { WinoIconGlyph.Folder, "\uE643" },
-        { WinoIconGlyph.Forward, "\uE7AA" },
-        { WinoIconGlyph.Inbox, "\uF516" },
-        { WinoIconGlyph.MarkRead, "\uF522" },
-        { WinoIconGlyph.MarkUnread, "\uF529" },
-        { WinoIconGlyph.MultiSelect, "\uE84D" },
-        { WinoIconGlyph.Save, "\uEA43" },
-        { WinoIconGlyph.CreateFolder, "\uE645" },
-        { WinoIconGlyph.Pin, "\uF5FF" },
-        { WinoIconGlyph.UnPin, "\uE985" },
-        { WinoIconGlyph.Star, "\uE734" },
-        { WinoIconGlyph.Ignore, "\uF5D0" },
-        { WinoIconGlyph.Find, "\uEA7D" },
-        { WinoIconGlyph.Zoom, "\uEE8E" },
-        { WinoIconGlyph.SpecialFolderInbox, "\uF516" },
-        { WinoIconGlyph.SpecialFolderStarred, "\uF70D" },
-        { WinoIconGlyph.SpecialFolderImportant, "\uE2F4" },
-        { WinoIconGlyph.SpecialFolderSent, "\uEA8E" },
-        { WinoIconGlyph.SpecialFolderDraft, "\uF3BE" },
-        { WinoIconGlyph.SpecialFolderArchive, "\uE066" },
-        { WinoIconGlyph.SpecialFolderDeleted, "\uEEA6" },
-        { WinoIconGlyph.SpecialFolderJunk, "\uF140" },
-        { WinoIconGlyph.SpecialFolderChat, "\uE8BD" },
-        { WinoIconGlyph.SpecialFolderCategory, "\uF599" },
-        { WinoIconGlyph.SpecialFolderUnread, "\uF529" },
-        { WinoIconGlyph.SpecialFolderForums, "\uF5B8" },
-        { WinoIconGlyph.SpecialFolderUpdated, "\uF565" },
-        { WinoIconGlyph.SpecialFolderPersonal, "\uE25A" },
-        { WinoIconGlyph.SpecialFolderPromotions, "\uF7B6" },
-        { WinoIconGlyph.SpecialFolderSocial, "\uEEEB" },
-        { WinoIconGlyph.SpecialFolderOther, "\uE643" },
-        { WinoIconGlyph.SpecialFolderMore, "\uF0F4" },
-        { WinoIconGlyph.Microsoft, "\uE904" },
-        { WinoIconGlyph.Google, "\uE905" },
-        { WinoIconGlyph.NewMail, "\uF107" },
-        { WinoIconGlyph.TurnOfNotifications, "\uF11D" },
-        { WinoIconGlyph.Rename, "\uF668" },
-        { WinoIconGlyph.EmptyFolder, "\uE47E" },
-        { WinoIconGlyph.DontSync, "\uF195" },
-        { WinoIconGlyph.Move, "\uE7B8" },
-        { WinoIconGlyph.Mail, "\uF509" },
-        { WinoIconGlyph.More, "\uE824" },
-        { WinoIconGlyph.CustomServer, "\uF509" },
-        { WinoIconGlyph.Print, "\uE922" },
-        { WinoIconGlyph.Attachment, "\uE723" },
-        { WinoIconGlyph.SortTextDesc, "\U000F3606" },
-        { WinoIconGlyph.SortLinesDesc, "\U000F038A" },
-        { WinoIconGlyph.Certificate, "\uEB95" },
-        { WinoIconGlyph.OpenInNewWindow, "\uE8A7" },
-        { WinoIconGlyph.Message, "\uE8BD" },
-        { WinoIconGlyph.New, "\U000F002A" },
-        { WinoIconGlyph.Blocked,"\uF140" },
-        { WinoIconGlyph.IMAP, "\uE715" },
-        { WinoIconGlyph.Calendar, "\uE912" },
-        { WinoIconGlyph.CalendarToday, "\uE911" },
-        { WinoIconGlyph.CalendarDay, "\uE913" },
-        { WinoIconGlyph.CalendarWeek, "\uE914" },
-        { WinoIconGlyph.CalendarMonth, "\uE91c" },
-        { WinoIconGlyph.CalendarYear, "\uE917" },
-        { WinoIconGlyph.WeatherBlow, "\uE907" },
-        { WinoIconGlyph.WeatherCloudy, "\uE920" },
-        { WinoIconGlyph.WeatherSunny, "\uE90e" },
-        { WinoIconGlyph.WeatherRainy, "\uE908" },
-        { WinoIconGlyph.WeatherSnowy, "\uE90a" },
-        { WinoIconGlyph.WeatherSnowShowerAtNight, "\uE90c" },
-        { WinoIconGlyph.WeatherThunderstorm, "\uE906" },
-        { WinoIconGlyph.CalendarEventRepeat, "\uE915" },
-        { WinoIconGlyph.CalendarEventMuiltiDay, "\uE91b" },
-        { WinoIconGlyph.Reminder, "\uE918" },
-        { WinoIconGlyph.CalendarAttendee, "\uE91a" },
-        { WinoIconGlyph.CalendarSync, "\uE91d" },
-        { WinoIconGlyph.CalendarError, "\uE916" },
-        { WinoIconGlyph.CalendarAttendees, "\uE929" },
-        { WinoIconGlyph.EventEditSeries, "\uE92A" },
-        { WinoIconGlyph.EventTentative, "\uE928" },
-        { WinoIconGlyph.EventAccept, "\uE925" },
-        { WinoIconGlyph.EventRespond, "\uE924" },
-        { WinoIconGlyph.EventReminder, "\uE923" },
-        { WinoIconGlyph.EventJoinOnline, "\uE926" },
-        { WinoIconGlyph.ViewMessageSource, "\uE943" },
-        { WinoIconGlyph.Apple, "\uE92B" },
-        { WinoIconGlyph.Yahoo, "\uE92C" }
-    };
+        public static Dictionary<WinoIconGlyph, string> WinoIconFontDictionary = new Dictionary<WinoIconGlyph, string>()
+        {
+            { WinoIconGlyph.None, "\u0020" },
+            { WinoIconGlyph.Archive, "\uE066" },
+            { WinoIconGlyph.UnArchive, "\uE06C" },
+            { WinoIconGlyph.Reply, "\uF176" },
+            { WinoIconGlyph.ReplyAll, "\uF17A" },
+            { WinoIconGlyph.Sync, "\uE895" },
+            { WinoIconGlyph.Send, "\uEA8E" },
+            { WinoIconGlyph.LightEditor, "\uE1F6" },
+            { WinoIconGlyph.Delete, "\uEEA6" },
+            { WinoIconGlyph.DarkEditor, "\uEE44" },
+            { WinoIconGlyph.Draft, "\uF3BE" },
+            { WinoIconGlyph.Flag, "\uF40C" },
+            { WinoIconGlyph.ClearFlag, "\uF40F" },
+            { WinoIconGlyph.Folder, "\uE643" },
+            { WinoIconGlyph.Forward, "\uE7AA" },
+            { WinoIconGlyph.Inbox, "\uF516" },
+            { WinoIconGlyph.MarkRead, "\uF522" },
+            { WinoIconGlyph.MarkUnread, "\uF529" },
+            { WinoIconGlyph.MultiSelect, "\uE84D" },
+            { WinoIconGlyph.Save, "\uEA43" },
+            { WinoIconGlyph.CreateFolder, "\uE645" },
+            { WinoIconGlyph.Pin, "\uF5FF" },
+            { WinoIconGlyph.UnPin, "\uE985" },
+            { WinoIconGlyph.Star, "\uE734" },
+            { WinoIconGlyph.Ignore, "\uF5D0" },
+            { WinoIconGlyph.Find, "\uEA7D" },
+            { WinoIconGlyph.Zoom, "\uEE8E" },
+            { WinoIconGlyph.SpecialFolderInbox, "\uF516" },
+            { WinoIconGlyph.SpecialFolderStarred, "\uF70D" },
+            { WinoIconGlyph.SpecialFolderImportant, "\uE2F4" },
+            { WinoIconGlyph.SpecialFolderSent, "\uEA8E" },
+            { WinoIconGlyph.SpecialFolderDraft, "\uF3BE" },
+            { WinoIconGlyph.SpecialFolderArchive, "\uE066" },
+            { WinoIconGlyph.SpecialFolderDeleted, "\uEEA6" },
+            { WinoIconGlyph.SpecialFolderJunk, "\uF140" },
+            { WinoIconGlyph.SpecialFolderChat, "\uE8BD" },
+            { WinoIconGlyph.SpecialFolderCategory, "\uF599" },
+            { WinoIconGlyph.SpecialFolderUnread, "\uF529" },
+            { WinoIconGlyph.SpecialFolderForums, "\uF5B8" },
+            { WinoIconGlyph.SpecialFolderUpdated, "\uF565" },
+            { WinoIconGlyph.SpecialFolderPersonal, "\uE25A" },
+            { WinoIconGlyph.SpecialFolderPromotions, "\uF7B6" },
+            { WinoIconGlyph.SpecialFolderSocial, "\uEEEB" },
+            { WinoIconGlyph.SpecialFolderOther, "\uE643" },
+            { WinoIconGlyph.SpecialFolderMore, "\uF0F4" },
+            { WinoIconGlyph.Microsoft, "\uE904" },
+            { WinoIconGlyph.Google, "\uE905" },
+            { WinoIconGlyph.NewMail, "\uF107" },
+            { WinoIconGlyph.TurnOfNotifications, "\uF11D" },
+            { WinoIconGlyph.Rename, "\uF668" },
+            { WinoIconGlyph.EmptyFolder, "\uE47E" },
+            { WinoIconGlyph.DontSync, "\uF195" },
+            { WinoIconGlyph.Move, "\uE7B8" },
+            { WinoIconGlyph.Mail, "\uF509" },
+            { WinoIconGlyph.More, "\uE824" },
+            { WinoIconGlyph.CustomServer, "\uF509" },
+            { WinoIconGlyph.Print, "\uE922" },
+            { WinoIconGlyph.Attachment, "\uE723" },
+            { WinoIconGlyph.SortTextDesc, "\U000F3606" },
+            { WinoIconGlyph.SortLinesDesc, "\U000F038A" },
+            { WinoIconGlyph.Certificate, "\uEB95" },
+            { WinoIconGlyph.OpenInNewWindow, "\uE8A7" },
+            { WinoIconGlyph.Message, "\uE8BD" },
+            { WinoIconGlyph.New, "\U000F002A" },
+            { WinoIconGlyph.Blocked,"\uF140" },
+            { WinoIconGlyph.IMAP, "\uE715" },
+            { WinoIconGlyph.Calendar, "\uE912" },
+            { WinoIconGlyph.CalendarToday, "\uE911" },
+            { WinoIconGlyph.CalendarDay, "\uE913" },
+            { WinoIconGlyph.CalendarWeek, "\uE914" },
+            { WinoIconGlyph.CalendarMonth, "\uE91c" },
+            { WinoIconGlyph.CalendarYear, "\uE917" },
+            { WinoIconGlyph.WeatherBlow, "\uE907" },
+            { WinoIconGlyph.WeatherCloudy, "\uE920" },
+            { WinoIconGlyph.WeatherSunny, "\uE90e" },
+            { WinoIconGlyph.WeatherRainy, "\uE908" },
+            { WinoIconGlyph.WeatherSnowy, "\uE90a" },
+            { WinoIconGlyph.WeatherSnowShowerAtNight, "\uE90c" },
+            { WinoIconGlyph.WeatherThunderstorm, "\uE906" },
+            { WinoIconGlyph.CalendarEventRepeat, "\uE915" },
+            { WinoIconGlyph.CalendarEventMuiltiDay, "\uE91b" },
+            { WinoIconGlyph.Reminder, "\uE918" },
+            { WinoIconGlyph.CalendarAttendee, "\uE91a" },
+            { WinoIconGlyph.CalendarSync, "\uE91d" },
+            { WinoIconGlyph.CalendarError, "\uE916" },
+            { WinoIconGlyph.CalendarAttendees, "\uE929" },
+            { WinoIconGlyph.EventEditSeries, "\uE92A" },
+            { WinoIconGlyph.EventTentative, "\uE928" },
+            { WinoIconGlyph.EventAccept, "\uE925" },
+            { WinoIconGlyph.EventRespond, "\uE924" },
+            { WinoIconGlyph.EventReminder, "\uE923" },
+            { WinoIconGlyph.EventJoinOnline, "\uE926" },
+            { WinoIconGlyph.ViewMessageSource, "\uE943" },
+            { WinoIconGlyph.Apple, "\uE92B" },
+            { WinoIconGlyph.Yahoo, "\uE92C" }
+        };
+    }
 }
--- a/Wino.Core.UWP/Controls/EqualGridPanel.cs
+++ b/Wino.Core.UWP/Controls/EqualGridPanel.cs
@@ -2,85 +2,86 @@
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;

-namespace Wino.Core.UWP.Controls;
-
-public partial class EqualGridPanel : Panel
+namespace Wino.Core.UWP.Controls
 {
-    public int Rows
+    public partial class EqualGridPanel : Panel
    {
-        get { return (int)GetValue(RowsProperty); }
-        set { SetValue(RowsProperty, value); }
-    }
-
-    public static readonly DependencyProperty RowsProperty =
-        DependencyProperty.Register(
-            nameof(Rows),
-            typeof(int),
-            typeof(EqualGridPanel),
-            new PropertyMetadata(1, OnLayoutPropertyChanged));
-
-    public int Columns
-    {
-        get { return (int)GetValue(ColumnsProperty); }
-        set { SetValue(ColumnsProperty, value); }
-    }
-
-    public static readonly DependencyProperty ColumnsProperty =
-        DependencyProperty.Register(
-            nameof(Columns),
-            typeof(int),
-            typeof(EqualGridPanel),
-            new PropertyMetadata(1, OnLayoutPropertyChanged));
-
-    private static void OnLayoutPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is EqualGridPanel panel)
+        public int Rows
        {
-            panel.InvalidateMeasure();
-            panel.InvalidateArrange();
-        }
-    }
-
-    protected override Size MeasureOverride(Size availableSize)
-    {
-        if (Rows <= 0 || Columns <= 0)
-        {
-            return new Size(0, 0);
+            get { return (int)GetValue(RowsProperty); }
+            set { SetValue(RowsProperty, value); }
        }

-        double cellWidth = availableSize.Width / Columns;
-        double cellHeight = availableSize.Height / Rows;
+        public static readonly DependencyProperty RowsProperty =
+            DependencyProperty.Register(
+                nameof(Rows),
+                typeof(int),
+                typeof(EqualGridPanel),
+                new PropertyMetadata(1, OnLayoutPropertyChanged));

-        foreach (UIElement child in Children)
+        public int Columns
        {
-            child.Measure(new Size(cellWidth, cellHeight));
+            get { return (int)GetValue(ColumnsProperty); }
+            set { SetValue(ColumnsProperty, value); }
        }

-        return availableSize;
-    }
+        public static readonly DependencyProperty ColumnsProperty =
+            DependencyProperty.Register(
+                nameof(Columns),
+                typeof(int),
+                typeof(EqualGridPanel),
+                new PropertyMetadata(1, OnLayoutPropertyChanged));

-    protected override Size ArrangeOverride(Size finalSize)
-    {
-        if (Rows <= 0 || Columns <= 0)
+        private static void OnLayoutPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
-            return new Size(0, 0);
+            if (d is EqualGridPanel panel)
+            {
+                panel.InvalidateMeasure();
+                panel.InvalidateArrange();
+            }
        }

-        double cellWidth = finalSize.Width / Columns;
-        double cellHeight = finalSize.Height / Rows;
-
-        for (int i = 0; i < Children.Count; i++)
+        protected override Size MeasureOverride(Size availableSize)
        {
-            int row = i / Columns;
-            int column = i % Columns;
+            if (Rows <= 0 || Columns <= 0)
+            {
+                return new Size(0, 0);
+            }

-            double x = column * cellWidth;
-            double y = row * cellHeight;
+            double cellWidth = availableSize.Width / Columns;
+            double cellHeight = availableSize.Height / Rows;

-            Rect rect = new Rect(x, y, cellWidth, cellHeight);
-            Children[i].Arrange(rect);
+            foreach (UIElement child in Children)
+            {
+                child.Measure(new Size(cellWidth, cellHeight));
+            }
+
+            return availableSize;
        }

-        return finalSize;
+        protected override Size ArrangeOverride(Size finalSize)
+        {
+            if (Rows <= 0 || Columns <= 0)
+            {
+                return new Size(0, 0);
+            }
+
+            double cellWidth = finalSize.Width / Columns;
+            double cellHeight = finalSize.Height / Rows;
+
+            for (int i = 0; i < Children.Count; i++)
+            {
+                int row = i / Columns;
+                int column = i % Columns;
+
+                double x = column * cellWidth;
+                double y = row * cellHeight;
+
+                Rect rect = new Rect(x, y, cellWidth, cellHeight);
+                Children[i].Arrange(rect);
+            }
+
+            return finalSize;
+        }
    }
 }
--- a/Wino.Core.UWP/Controls/WinoAppTitleBar.xaml.cs
+++ b/Wino.Core.UWP/Controls/WinoAppTitleBar.xaml.cs
@@ -4,208 +4,193 @@ using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 using Wino.Core.Domain.Enums;

-namespace Wino.Core.UWP.Controls;
-
-public sealed partial class WinoAppTitleBar : UserControl
+namespace Wino.Core.UWP.Controls
 {
-    public event TypedEventHandler<WinoAppTitleBar, RoutedEventArgs> BackButtonClicked;
-
-    public static readonly DependencyProperty IsRenderingPaneVisibleProperty = DependencyProperty.Register(nameof(IsRenderingPaneVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty IsReaderNarrowedProperty = DependencyProperty.Register(nameof(IsReaderNarrowed), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnIsReaderNarrowedChanged));
-    public static readonly DependencyProperty IsBackButtonVisibleProperty = DependencyProperty.Register(nameof(IsBackButtonVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty OpenPaneLengthProperty = DependencyProperty.Register(nameof(OpenPaneLength), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(0d, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty IsNavigationPaneOpenProperty = DependencyProperty.Register(nameof(IsNavigationPaneOpen), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty NavigationViewDisplayModeProperty = DependencyProperty.Register(nameof(NavigationViewDisplayMode), typeof(Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode), typeof(WinoAppTitleBar), new PropertyMetadata(Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Compact, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty ShellFrameContentProperty = DependencyProperty.Register(nameof(ShellFrameContent), typeof(UIElement), typeof(WinoAppTitleBar), new PropertyMetadata(null, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty SystemReservedProperty = DependencyProperty.Register(nameof(SystemReserved), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(0, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty CoreWindowTextProperty = DependencyProperty.Register(nameof(CoreWindowText), typeof(string), typeof(WinoAppTitleBar), new PropertyMetadata(string.Empty, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty ReadingPaneLengthProperty = DependencyProperty.Register(nameof(ReadingPaneLength), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(420d, OnDrawingPropertyChanged));
-    public static readonly DependencyProperty ConnectionStatusProperty = DependencyProperty.Register(nameof(ConnectionStatus), typeof(WinoServerConnectionStatus), typeof(WinoAppTitleBar), new PropertyMetadata(WinoServerConnectionStatus.None, new PropertyChangedCallback(OnConnectionStatusChanged)));
-    public static readonly DependencyProperty ReconnectCommandProperty = DependencyProperty.Register(nameof(ReconnectCommand), typeof(ICommand), typeof(WinoAppTitleBar), new PropertyMetadata(null));
-    public static readonly DependencyProperty ShrinkShellContentOnExpansionProperty = DependencyProperty.Register(nameof(ShrinkShellContentOnExpansion), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));
-    public static readonly DependencyProperty IsDragAreaProperty = DependencyProperty.Register(nameof(IsDragArea), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, new PropertyChangedCallback(OnIsDragAreaChanged)));
-    public static readonly DependencyProperty IsShellFrameContentVisibleProperty = DependencyProperty.Register(nameof(IsShellFrameContentVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));
-    public static readonly DependencyProperty IsMenuButtonVisibleProperty = DependencyProperty.Register(nameof(IsMenuButtonVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));
-
-    public bool IsShellFrameContentVisible
+    public sealed partial class WinoAppTitleBar : UserControl
    {
-        get { return (bool)GetValue(IsShellFrameContentVisibleProperty); }
-        set { SetValue(IsShellFrameContentVisibleProperty, value); }
-    }
+        public event TypedEventHandler<WinoAppTitleBar, RoutedEventArgs> BackButtonClicked;

-    public ICommand ReconnectCommand
-    {
-        get { return (ICommand)GetValue(ReconnectCommandProperty); }
-        set { SetValue(ReconnectCommandProperty, value); }
-    }
+        public static readonly DependencyProperty IsRenderingPaneVisibleProperty = DependencyProperty.Register(nameof(IsRenderingPaneVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty IsReaderNarrowedProperty = DependencyProperty.Register(nameof(IsReaderNarrowed), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnIsReaderNarrowedChanged));
+        public static readonly DependencyProperty IsBackButtonVisibleProperty = DependencyProperty.Register(nameof(IsBackButtonVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty OpenPaneLengthProperty = DependencyProperty.Register(nameof(OpenPaneLength), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(0d, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty IsNavigationPaneOpenProperty = DependencyProperty.Register(nameof(IsNavigationPaneOpen), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty NavigationViewDisplayModeProperty = DependencyProperty.Register(nameof(NavigationViewDisplayMode), typeof(Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode), typeof(WinoAppTitleBar), new PropertyMetadata(Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Compact, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty ShellFrameContentProperty = DependencyProperty.Register(nameof(ShellFrameContent), typeof(UIElement), typeof(WinoAppTitleBar), new PropertyMetadata(null, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty SystemReservedProperty = DependencyProperty.Register(nameof(SystemReserved), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(0, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty CoreWindowTextProperty = DependencyProperty.Register(nameof(CoreWindowText), typeof(string), typeof(WinoAppTitleBar), new PropertyMetadata(string.Empty, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty ReadingPaneLengthProperty = DependencyProperty.Register(nameof(ReadingPaneLength), typeof(double), typeof(WinoAppTitleBar), new PropertyMetadata(420d, OnDrawingPropertyChanged));
+        public static readonly DependencyProperty ConnectionStatusProperty = DependencyProperty.Register(nameof(ConnectionStatus), typeof(WinoServerConnectionStatus), typeof(WinoAppTitleBar), new PropertyMetadata(WinoServerConnectionStatus.None, new PropertyChangedCallback(OnConnectionStatusChanged)));
+        public static readonly DependencyProperty ReconnectCommandProperty = DependencyProperty.Register(nameof(ReconnectCommand), typeof(ICommand), typeof(WinoAppTitleBar), new PropertyMetadata(null));
+        public static readonly DependencyProperty ShrinkShellContentOnExpansionProperty = DependencyProperty.Register(nameof(ShrinkShellContentOnExpansion), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));
+        public static readonly DependencyProperty IsDragAreaProperty = DependencyProperty.Register(nameof(IsDragArea), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(false, new PropertyChangedCallback(OnIsDragAreaChanged)));
+        public static readonly DependencyProperty IsShellFrameContentVisibleProperty = DependencyProperty.Register(nameof(IsShellFrameContentVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));
+        public static readonly DependencyProperty IsMenuButtonVisibleProperty = DependencyProperty.Register(nameof(IsMenuButtonVisible), typeof(bool), typeof(WinoAppTitleBar), new PropertyMetadata(true));

-    public WinoServerConnectionStatus ConnectionStatus
-    {
-        get { return (WinoServerConnectionStatus)GetValue(ConnectionStatusProperty); }
-        set { SetValue(ConnectionStatusProperty, value); }
-    }
-
-    public string CoreWindowText
-    {
-        get { return (string)GetValue(CoreWindowTextProperty); }
-        set { SetValue(CoreWindowTextProperty, value); }
-    }
-
-    public bool IsDragArea
-    {
-        get { return (bool)GetValue(IsDragAreaProperty); }
-        set { SetValue(IsDragAreaProperty, value); }
-    }
-
-
-    public double SystemReserved
-    {
-        get { return (double)GetValue(SystemReservedProperty); }
-        set { SetValue(SystemReservedProperty, value); }
-    }
-
-    public UIElement ShellFrameContent
-    {
-        get { return (UIElement)GetValue(ShellFrameContentProperty); }
-        set { SetValue(ShellFrameContentProperty, value); }
-    }
-
-    public Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode NavigationViewDisplayMode
-    {
-        get { return (Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode)GetValue(NavigationViewDisplayModeProperty); }
-        set { SetValue(NavigationViewDisplayModeProperty, value); }
-    }
-
-    public bool ShrinkShellContentOnExpansion
-    {
-        get { return (bool)GetValue(ShrinkShellContentOnExpansionProperty); }
-        set { SetValue(ShrinkShellContentOnExpansionProperty, value); }
-    }
-
-    public bool IsNavigationPaneOpen
-    {
-        get { return (bool)GetValue(IsNavigationPaneOpenProperty); }
-        set { SetValue(IsNavigationPaneOpenProperty, value); }
-    }
-
-    public double OpenPaneLength
-    {
-        get { return (double)GetValue(OpenPaneLengthProperty); }
-        set { SetValue(OpenPaneLengthProperty, value); }
-    }
-
-
-
-    public bool IsMenuButtonVisible
-    {
-        get { return (bool)GetValue(IsMenuButtonVisibleProperty); }
-        set { SetValue(IsMenuButtonVisibleProperty, value); }
-    }
-
-
-    public bool IsBackButtonVisible
-    {
-        get { return (bool)GetValue(IsBackButtonVisibleProperty); }
-        set { SetValue(IsBackButtonVisibleProperty, value); }
-    }
-
-    public bool IsReaderNarrowed
-    {
-        get { return (bool)GetValue(IsReaderNarrowedProperty); }
-        set { SetValue(IsReaderNarrowedProperty, value); }
-    }
-
-    public bool IsRenderingPaneVisible
-    {
-        get { return (bool)GetValue(IsRenderingPaneVisibleProperty); }
-        set { SetValue(IsRenderingPaneVisibleProperty, value); }
-    }
-
-    public double ReadingPaneLength
-    {
-        get { return (double)GetValue(ReadingPaneLengthProperty); }
-        set { SetValue(ReadingPaneLengthProperty, value); }
-    }
-
-    private static void OnIsReaderNarrowedChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoAppTitleBar bar)
+        public bool IsShellFrameContentVisible
        {
-            bar.DrawTitleBar();
+            get { return (bool)GetValue(IsShellFrameContentVisibleProperty); }
+            set { SetValue(IsShellFrameContentVisibleProperty, value); }
        }
-    }

-    private static void OnDrawingPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoAppTitleBar bar)
+        public ICommand ReconnectCommand
        {
-            bar.DrawTitleBar();
+            get { return (ICommand)GetValue(ReconnectCommandProperty); }
+            set { SetValue(ReconnectCommandProperty, value); }
        }
-    }

-    private static void OnConnectionStatusChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoAppTitleBar bar)
+        public WinoServerConnectionStatus ConnectionStatus
        {
-            bar.UpdateConnectionStatus();
+            get { return (WinoServerConnectionStatus)GetValue(ConnectionStatusProperty); }
+            set { SetValue(ConnectionStatusProperty, value); }
        }
-    }

-    private static void OnIsDragAreaChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoAppTitleBar bar)
+        public string CoreWindowText
        {
-            bar.SetDragArea();
+            get { return (string)GetValue(CoreWindowTextProperty); }
+            set { SetValue(CoreWindowTextProperty, value); }
        }
-    }

-    private void SetDragArea()
-    {
-        if (IsDragArea)
+        public bool IsDragArea
        {
-            Window.Current.SetTitleBar(dragbar);
+            get { return (bool)GetValue(IsDragAreaProperty); }
+            set { SetValue(IsDragAreaProperty, value); }
        }
-    }

-    private void UpdateConnectionStatus()
-    {

-    }
-
-    private void DrawTitleBar()
-    {
-        UpdateLayout();
-
-        CoreWindowTitleTextBlock.Visibility = Visibility.Collapsed;
-        ShellContentContainer.Width = double.NaN;
-        ShellContentContainer.Margin = new Thickness(0, 0, 0, 0);
-        ShellContentContainer.HorizontalAlignment = HorizontalAlignment.Stretch;
-
-        EmptySpaceWidth.Width = new GridLength(1, GridUnitType.Star);
-
-        // Menu is not visible.
-        if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Minimal)
+        public double SystemReserved
        {
-
+            get { return (double)GetValue(SystemReservedProperty); }
+            set { SetValue(SystemReservedProperty, value); }
        }
-        else if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Compact)
-        {
-            // Icons are visible.

-            if (!IsReaderNarrowed && ShrinkShellContentOnExpansion)
+        public UIElement ShellFrameContent
+        {
+            get { return (UIElement)GetValue(ShellFrameContentProperty); }
+            set { SetValue(ShellFrameContentProperty, value); }
+        }
+
+        public Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode NavigationViewDisplayMode
+        {
+            get { return (Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode)GetValue(NavigationViewDisplayModeProperty); }
+            set { SetValue(NavigationViewDisplayModeProperty, value); }
+        }
+
+        public bool ShrinkShellContentOnExpansion
+        {
+            get { return (bool)GetValue(ShrinkShellContentOnExpansionProperty); }
+            set { SetValue(ShrinkShellContentOnExpansionProperty, value); }
+        }
+
+        public bool IsNavigationPaneOpen
+        {
+            get { return (bool)GetValue(IsNavigationPaneOpenProperty); }
+            set { SetValue(IsNavigationPaneOpenProperty, value); }
+        }
+
+        public double OpenPaneLength
+        {
+            get { return (double)GetValue(OpenPaneLengthProperty); }
+            set { SetValue(OpenPaneLengthProperty, value); }
+        }
+
+
+
+        public bool IsMenuButtonVisible
+        {
+            get { return (bool)GetValue(IsMenuButtonVisibleProperty); }
+            set { SetValue(IsMenuButtonVisibleProperty, value); }
+        }
+
+
+        public bool IsBackButtonVisible
+        {
+            get { return (bool)GetValue(IsBackButtonVisibleProperty); }
+            set { SetValue(IsBackButtonVisibleProperty, value); }
+        }
+
+        public bool IsReaderNarrowed
+        {
+            get { return (bool)GetValue(IsReaderNarrowedProperty); }
+            set { SetValue(IsReaderNarrowedProperty, value); }
+        }
+
+        public bool IsRenderingPaneVisible
+        {
+            get { return (bool)GetValue(IsRenderingPaneVisibleProperty); }
+            set { SetValue(IsRenderingPaneVisibleProperty, value); }
+        }
+
+        public double ReadingPaneLength
+        {
+            get { return (double)GetValue(ReadingPaneLengthProperty); }
+            set { SetValue(ReadingPaneLengthProperty, value); }
+        }
+
+        private static void OnIsReaderNarrowedChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoAppTitleBar bar)
            {
-                ShellContentContainer.HorizontalAlignment = HorizontalAlignment.Left;
-                ShellContentContainer.Width = ReadingPaneLength;
+                bar.DrawTitleBar();
            }
        }
-        else if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Expanded)
-        {
-            if (IsNavigationPaneOpen)
-            {
-                CoreWindowTitleTextBlock.Visibility = Visibility.Visible;

-                // LMargin = OpenPaneLength - LeftMenuStackPanel
-                ShellContentContainer.Margin = new Thickness(OpenPaneLength - LeftMenuStackPanel.ActualSize.X, 0, 0, 0);
+        private static void OnDrawingPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoAppTitleBar bar)
+            {
+                bar.DrawTitleBar();
+            }
+        }
+
+        private static void OnConnectionStatusChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoAppTitleBar bar)
+            {
+                bar.UpdateConnectionStatus();
+            }
+        }
+
+        private static void OnIsDragAreaChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoAppTitleBar bar)
+            {
+                bar.SetDragArea();
+            }
+        }
+
+        private void SetDragArea()
+        {
+            if (IsDragArea)
+            {
+                Window.Current.SetTitleBar(dragbar);
+            }
+        }
+
+        private void UpdateConnectionStatus()
+        {
+
+        }
+
+        private void DrawTitleBar()
+        {
+            UpdateLayout();
+
+            CoreWindowTitleTextBlock.Visibility = Visibility.Collapsed;
+            ShellContentContainer.Width = double.NaN;
+            ShellContentContainer.Margin = new Thickness(0, 0, 0, 0);
+            ShellContentContainer.HorizontalAlignment = HorizontalAlignment.Stretch;
+
+            EmptySpaceWidth.Width = new GridLength(1, GridUnitType.Star);
+
+            // Menu is not visible.
+            if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Minimal)
+            {
+
+            }
+            else if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Compact)
+            {
+                // Icons are visible.

                if (!IsReaderNarrowed && ShrinkShellContentOnExpansion)
                {
@@ -213,43 +198,59 @@ public sealed partial class WinoAppTitleBar : UserControl
                    ShellContentContainer.Width = ReadingPaneLength;
                }
            }
-            else
+            else if (NavigationViewDisplayMode == Microsoft.UI.Xaml.Controls.NavigationViewDisplayMode.Expanded)
            {
-                if (ShrinkShellContentOnExpansion)
+                if (IsNavigationPaneOpen)
                {
-                    EmptySpaceWidth.Width = new GridLength(ReadingPaneLength, GridUnitType.Pixel);
+                    CoreWindowTitleTextBlock.Visibility = Visibility.Visible;
+
+                    // LMargin = OpenPaneLength - LeftMenuStackPanel
+                    ShellContentContainer.Margin = new Thickness(OpenPaneLength - LeftMenuStackPanel.ActualSize.X, 0, 0, 0);
+
+                    if (!IsReaderNarrowed && ShrinkShellContentOnExpansion)
+                    {
+                        ShellContentContainer.HorizontalAlignment = HorizontalAlignment.Left;
+                        ShellContentContainer.Width = ReadingPaneLength;
+                    }
                }
                else
                {
-                    EmptySpaceWidth.Width = new GridLength(ReadingPaneLength, GridUnitType.Star);
+                    if (ShrinkShellContentOnExpansion)
+                    {
+                        EmptySpaceWidth.Width = new GridLength(ReadingPaneLength, GridUnitType.Pixel);
+                    }
+                    else
+                    {
+                        EmptySpaceWidth.Width = new GridLength(ReadingPaneLength, GridUnitType.Star);
+                    }
                }
            }
        }
-    }

-    public WinoAppTitleBar()
-    {
-        InitializeComponent();
-    }
+        public WinoAppTitleBar()
+        {
+            InitializeComponent();
+        }

-    private void BackClicked(object sender, RoutedEventArgs e)
-    {
-        BackButtonClicked?.Invoke(this, e);
-    }
+        private void BackClicked(object sender, RoutedEventArgs e)
+        {
+            BackButtonClicked?.Invoke(this, e);
+        }

-    private void PaneClicked(object sender, RoutedEventArgs e)
-    {
-        IsNavigationPaneOpen = !IsNavigationPaneOpen;
-    }
+        private void PaneClicked(object sender, RoutedEventArgs e)
+        {
+            IsNavigationPaneOpen = !IsNavigationPaneOpen;
+        }

-    private void TitlebarSizeChanged(object sender, SizeChangedEventArgs e) => DrawTitleBar();
+        private void TitlebarSizeChanged(object sender, SizeChangedEventArgs e) => DrawTitleBar();

-    private void ReconnectClicked(object sender, RoutedEventArgs e)
-    {
-        // Close the popup for reconnect button.
-        ReconnectFlyout.Hide();
+        private void ReconnectClicked(object sender, RoutedEventArgs e)
+        {
+            // Close the popup for reconnect button.
+            ReconnectFlyout.Hide();

-        // Execute the reconnect command.
-        ReconnectCommand?.Execute(null);
+            // Execute the reconnect command.
+            ReconnectCommand?.Execute(null);
+        }
    }
 }
--- a/Wino.Core.UWP/Controls/WinoFontIcon.cs
+++ b/Wino.Core.UWP/Controls/WinoFontIcon.cs
@@ -1,135 +1,136 @@
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;

-namespace Wino.Core.UWP.Controls;
-
-public enum WinoIconGlyph
+namespace Wino.Core.UWP.Controls
 {
-    None,
-    NewMail,
-    Google,
-    Microsoft,
-    CustomServer,
-    Archive,
-    UnArchive,
-    Reply,
-    ReplyAll,
-    LightEditor,
-    DarkEditor,
-    Delete,
-    Move,
-    Mail,
-    Draft,
-    Flag,
-    ClearFlag,
-    Folder,
-    Forward,
-    Inbox,
-    MarkRead,
-    MarkUnread,
-    Send,
-    Save,
-    Sync,
-    MultiSelect,
-    Zoom,
-    Pin,
-    UnPin,
-    Ignore,
-    Star,
-    CreateFolder,
-    More,
-    Find,
-    SpecialFolderInbox,
-    SpecialFolderStarred,
-    SpecialFolderImportant,
-    SpecialFolderSent,
-    SpecialFolderDraft,
-    SpecialFolderArchive,
-    SpecialFolderDeleted,
-    SpecialFolderJunk,
-    SpecialFolderChat,
-    SpecialFolderCategory,
-    SpecialFolderUnread,
-    SpecialFolderForums,
-    SpecialFolderUpdated,
-    SpecialFolderPersonal,
-    SpecialFolderPromotions,
-    SpecialFolderSocial,
-    SpecialFolderOther,
-    SpecialFolderMore,
-    TurnOfNotifications,
-    EmptyFolder,
-    Rename,
-    DontSync,
-    Attachment,
-    SortTextDesc,
-    SortLinesDesc,
-    Certificate,
-    OpenInNewWindow,
-    Blocked,
-    Message,
-    New,
-    IMAP,
-    Print,
-    Calendar,
-    CalendarToday,
-    CalendarDay,
-    CalendarWeek,
-    CalendarWorkWeek,
-    CalendarMonth,
-    CalendarYear,
-    WeatherBlow,
-    WeatherCloudy,
-    WeatherSunny,
-    WeatherRainy,
-    WeatherSnowy,
-    WeatherSnowShowerAtNight,
-    WeatherThunderstorm,
-    CalendarEventRepeat,
-    CalendarEventMuiltiDay,
-    CalendarError,
-    Reminder,
-    CalendarAttendee,
-    CalendarAttendees,
-    CalendarSync,
-    EventRespond,
-    EventAccept,
-    EventTentative,
-    EventDecline,
-    EventReminder,
-    EventEditSeries,
-    EventJoinOnline,
-    ViewMessageSource,
-    Apple,
-    Yahoo
-}
-
-public partial class WinoFontIcon : FontIcon
-{
-    public WinoIconGlyph Icon
+    public enum WinoIconGlyph
    {
-        get { return (WinoIconGlyph)GetValue(IconProperty); }
-        set { SetValue(IconProperty, value); }
+        None,
+        NewMail,
+        Google,
+        Microsoft,
+        CustomServer,
+        Archive,
+        UnArchive,
+        Reply,
+        ReplyAll,
+        LightEditor,
+        DarkEditor,
+        Delete,
+        Move,
+        Mail,
+        Draft,
+        Flag,
+        ClearFlag,
+        Folder,
+        Forward,
+        Inbox,
+        MarkRead,
+        MarkUnread,
+        Send,
+        Save,
+        Sync,
+        MultiSelect,
+        Zoom,
+        Pin,
+        UnPin,
+        Ignore,
+        Star,
+        CreateFolder,
+        More,
+        Find,
+        SpecialFolderInbox,
+        SpecialFolderStarred,
+        SpecialFolderImportant,
+        SpecialFolderSent,
+        SpecialFolderDraft,
+        SpecialFolderArchive,
+        SpecialFolderDeleted,
+        SpecialFolderJunk,
+        SpecialFolderChat,
+        SpecialFolderCategory,
+        SpecialFolderUnread,
+        SpecialFolderForums,
+        SpecialFolderUpdated,
+        SpecialFolderPersonal,
+        SpecialFolderPromotions,
+        SpecialFolderSocial,
+        SpecialFolderOther,
+        SpecialFolderMore,
+        TurnOfNotifications,
+        EmptyFolder,
+        Rename,
+        DontSync,
+        Attachment,
+        SortTextDesc,
+        SortLinesDesc,
+        Certificate,
+        OpenInNewWindow,
+        Blocked,
+        Message,
+        New,
+        IMAP,
+        Print,
+        Calendar,
+        CalendarToday,
+        CalendarDay,
+        CalendarWeek,
+        CalendarWorkWeek,
+        CalendarMonth,
+        CalendarYear,
+        WeatherBlow,
+        WeatherCloudy,
+        WeatherSunny,
+        WeatherRainy,
+        WeatherSnowy,
+        WeatherSnowShowerAtNight,
+        WeatherThunderstorm,
+        CalendarEventRepeat,
+        CalendarEventMuiltiDay,
+        CalendarError,
+        Reminder,
+        CalendarAttendee,
+        CalendarAttendees,
+        CalendarSync,
+        EventRespond,
+        EventAccept,
+        EventTentative,
+        EventDecline,
+        EventReminder,
+        EventEditSeries,
+        EventJoinOnline,
+        ViewMessageSource,
+        Apple,
+        Yahoo
    }

-    public static readonly DependencyProperty IconProperty = DependencyProperty.Register(nameof(Icon), typeof(WinoIconGlyph), typeof(WinoFontIcon), new PropertyMetadata(WinoIconGlyph.Flag, OnIconChanged));
-
-    public WinoFontIcon()
+    public partial class WinoFontIcon : FontIcon
    {
-        FontFamily = new Windows.UI.Xaml.Media.FontFamily("ms-appx:///Wino.Core.UWP/Assets/WinoIcons.ttf#WinoIcons");
-        FontSize = 32;
-    }
-
-    private static void OnIconChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoFontIcon fontIcon)
+        public WinoIconGlyph Icon
        {
-            fontIcon.UpdateGlyph();
+            get { return (WinoIconGlyph)GetValue(IconProperty); }
+            set { SetValue(IconProperty, value); }
+        }
+
+        public static readonly DependencyProperty IconProperty = DependencyProperty.Register(nameof(Icon), typeof(WinoIconGlyph), typeof(WinoFontIcon), new PropertyMetadata(WinoIconGlyph.Flag, OnIconChanged));
+
+        public WinoFontIcon()
+        {
+            FontFamily = new Windows.UI.Xaml.Media.FontFamily("ms-appx:///Wino.Core.UWP/Assets/WinoIcons.ttf#WinoIcons");
+            FontSize = 32;
+        }
+
+        private static void OnIconChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoFontIcon fontIcon)
+            {
+                fontIcon.UpdateGlyph();
+            }
+        }
+
+        private void UpdateGlyph()
+        {
+            Glyph = ControlConstants.WinoIconFontDictionary[Icon];
        }
    }
-
-    private void UpdateGlyph()
-    {
-        Glyph = ControlConstants.WinoIconFontDictionary[Icon];
-    }
 }
--- a/Wino.Core.UWP/Controls/WinoFontIconSource.cs
+++ b/Wino.Core.UWP/Controls/WinoFontIconSource.cs
@@ -1,34 +1,35 @@
 using Windows.UI.Xaml;
 using Wino.Core.UWP.Controls;

-namespace Wino.Controls;
-
-public partial class WinoFontIconSource : Microsoft.UI.Xaml.Controls.FontIconSource
+namespace Wino.Controls
 {
-    public WinoIconGlyph Icon
+    public partial class WinoFontIconSource : Microsoft.UI.Xaml.Controls.FontIconSource
    {
-        get { return (WinoIconGlyph)GetValue(IconProperty); }
-        set { SetValue(IconProperty, value); }
-    }
-
-    public static readonly DependencyProperty IconProperty = DependencyProperty.Register(nameof(Icon), typeof(WinoIconGlyph), typeof(WinoFontIconSource), new PropertyMetadata(WinoIconGlyph.Flag, OnIconChanged));
-
-    public WinoFontIconSource()
-    {
-        FontFamily = new Windows.UI.Xaml.Media.FontFamily("ms-appx:///Assets/WinoIcons.ttf#WinoIcons");
-        FontSize = 32;
-    }
-
-    private static void OnIconChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoFontIconSource fontIcon)
+        public WinoIconGlyph Icon
        {
-            fontIcon.UpdateGlyph();
+            get { return (WinoIconGlyph)GetValue(IconProperty); }
+            set { SetValue(IconProperty, value); }
+        }
+
+        public static readonly DependencyProperty IconProperty = DependencyProperty.Register(nameof(Icon), typeof(WinoIconGlyph), typeof(WinoFontIconSource), new PropertyMetadata(WinoIconGlyph.Flag, OnIconChanged));
+
+        public WinoFontIconSource()
+        {
+            FontFamily = new Windows.UI.Xaml.Media.FontFamily("ms-appx:///Assets/WinoIcons.ttf#WinoIcons");
+            FontSize = 32;
+        }
+
+        private static void OnIconChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoFontIconSource fontIcon)
+            {
+                fontIcon.UpdateGlyph();
+            }
+        }
+
+        private void UpdateGlyph()
+        {
+            Glyph = ControlConstants.WinoIconFontDictionary[Icon];
        }
    }
-
-    private void UpdateGlyph()
-    {
-        Glyph = ControlConstants.WinoIconFontDictionary[Icon];
-    }
 }
--- a/Wino.Core.UWP/Controls/WinoInfoBar.cs
+++ b/Wino.Core.UWP/Controls/WinoInfoBar.cs
@@ -5,86 +5,87 @@ using Microsoft.UI.Xaml.Controls;
 using Windows.UI.Xaml;
 using Wino.Core.Domain.Enums;

-namespace Wino.Core.UWP.Controls;
-
-public partial class WinoInfoBar : InfoBar
+namespace Wino.Core.UWP.Controls
 {
-    public static readonly DependencyProperty AnimationTypeProperty = DependencyProperty.Register(nameof(AnimationType), typeof(InfoBarAnimationType), typeof(WinoInfoBar), new PropertyMetadata(InfoBarAnimationType.SlideFromRightToLeft));
-    public static readonly DependencyProperty DismissIntervalProperty = DependencyProperty.Register(nameof(DismissInterval), typeof(int), typeof(WinoInfoBar), new PropertyMetadata(5, new PropertyChangedCallback(OnDismissIntervalChanged)));
-
-    public InfoBarAnimationType AnimationType
+    public partial class WinoInfoBar : InfoBar
    {
-        get { return (InfoBarAnimationType)GetValue(AnimationTypeProperty); }
-        set { SetValue(AnimationTypeProperty, value); }
-    }
+        public static readonly DependencyProperty AnimationTypeProperty = DependencyProperty.Register(nameof(AnimationType), typeof(InfoBarAnimationType), typeof(WinoInfoBar), new PropertyMetadata(InfoBarAnimationType.SlideFromRightToLeft));
+        public static readonly DependencyProperty DismissIntervalProperty = DependencyProperty.Register(nameof(DismissInterval), typeof(int), typeof(WinoInfoBar), new PropertyMetadata(5, new PropertyChangedCallback(OnDismissIntervalChanged)));

-    public int DismissInterval
-    {
-        get { return (int)GetValue(DismissIntervalProperty); }
-        set { SetValue(DismissIntervalProperty, value); }
-    }
-
-    private readonly DispatcherTimer _dispatcherTimer = new DispatcherTimer();
-
-    public WinoInfoBar()
-    {
-        RegisterPropertyChangedCallback(IsOpenProperty, IsOpenChanged);
-
-        _dispatcherTimer.Interval = TimeSpan.FromSeconds(DismissInterval);
-    }
-
-    private static void OnDismissIntervalChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoInfoBar bar)
+        public InfoBarAnimationType AnimationType
        {
-            bar.UpdateInterval(bar.DismissInterval);
+            get { return (InfoBarAnimationType)GetValue(AnimationTypeProperty); }
+            set { SetValue(AnimationTypeProperty, value); }
        }
-    }

-    private void UpdateInterval(int seconds) => _dispatcherTimer.Interval = TimeSpan.FromSeconds(seconds);
-
-    private async void IsOpenChanged(DependencyObject sender, DependencyProperty dp)
-    {
-        if (sender is WinoInfoBar control)
+        public int DismissInterval
        {
-            // Message shown.
-            if (!control.IsOpen) return;
+            get { return (int)GetValue(DismissIntervalProperty); }
+            set { SetValue(DismissIntervalProperty, value); }
+        }

-            Opacity = 1;
+        private readonly DispatcherTimer _dispatcherTimer = new DispatcherTimer();

+        public WinoInfoBar()
+        {
+            RegisterPropertyChangedCallback(IsOpenProperty, IsOpenChanged);
+
+            _dispatcherTimer.Interval = TimeSpan.FromSeconds(DismissInterval);
+        }
+
+        private static void OnDismissIntervalChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoInfoBar bar)
+            {
+                bar.UpdateInterval(bar.DismissInterval);
+            }
+        }
+
+        private void UpdateInterval(int seconds) => _dispatcherTimer.Interval = TimeSpan.FromSeconds(seconds);
+
+        private async void IsOpenChanged(DependencyObject sender, DependencyProperty dp)
+        {
+            if (sender is WinoInfoBar control)
+            {
+                // Message shown.
+                if (!control.IsOpen) return;
+
+                Opacity = 1;
+
+                _dispatcherTimer.Stop();
+
+                _dispatcherTimer.Tick -= TimerTick;
+                _dispatcherTimer.Tick += TimerTick;
+
+                _dispatcherTimer.Start();
+
+                // Slide from right.
+                if (AnimationType == InfoBarAnimationType.SlideFromRightToLeft)
+                {
+                    await AnimationBuilder.Create().Translation(new Vector3(0, 0, 0), new Vector3(150, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
+                }
+                else if (AnimationType == InfoBarAnimationType.SlideFromBottomToTop)
+                {
+                    await AnimationBuilder.Create().Translation(new Vector3(0, 0, 0), new Vector3(0, 50, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
+                }
+            }
+        }
+
+        private async void TimerTick(object sender, object e)
+        {
            _dispatcherTimer.Stop();
-
            _dispatcherTimer.Tick -= TimerTick;
-            _dispatcherTimer.Tick += TimerTick;

-            _dispatcherTimer.Start();
-
-            // Slide from right.
            if (AnimationType == InfoBarAnimationType.SlideFromRightToLeft)
            {
-                await AnimationBuilder.Create().Translation(new Vector3(0, 0, 0), new Vector3(150, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
+                await AnimationBuilder.Create().Translation(new Vector3((float)ActualWidth, 0, 0), new Vector3(0, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
            }
            else if (AnimationType == InfoBarAnimationType.SlideFromBottomToTop)
            {
-                await AnimationBuilder.Create().Translation(new Vector3(0, 0, 0), new Vector3(0, 50, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
+                await AnimationBuilder.Create().Translation(new Vector3(0, (float)ActualHeight, 0), new Vector3(0, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
            }
-        }
-    }

-    private async void TimerTick(object sender, object e)
-    {
-        _dispatcherTimer.Stop();
-        _dispatcherTimer.Tick -= TimerTick;
-
-        if (AnimationType == InfoBarAnimationType.SlideFromRightToLeft)
-        {
-            await AnimationBuilder.Create().Translation(new Vector3((float)ActualWidth, 0, 0), new Vector3(0, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
+            IsOpen = false;
        }
-        else if (AnimationType == InfoBarAnimationType.SlideFromBottomToTop)
-        {
-            await AnimationBuilder.Create().Translation(new Vector3(0, (float)ActualHeight, 0), new Vector3(0, 0, 0), null, TimeSpan.FromSeconds(0.5)).StartAsync(this);
-        }
-
-        IsOpen = false;
    }
 }
--- a/Wino.Core.UWP/Controls/WinoNavigationViewItem.cs
+++ b/Wino.Core.UWP/Controls/WinoNavigationViewItem.cs
@@ -3,44 +3,45 @@ using Microsoft.UI.Xaml.Controls;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Hosting;

-namespace Wino.Core.UWP.Controls;
-
-public partial class WinoNavigationViewItem : NavigationViewItem
+namespace Wino.Core.UWP.Controls
 {
-    public bool IsDraggingItemOver
+    public partial class WinoNavigationViewItem : NavigationViewItem
    {
-        get { return (bool)GetValue(IsDraggingItemOverProperty); }
-        set { SetValue(IsDraggingItemOverProperty, value); }
-    }
-
-    public static readonly DependencyProperty IsDraggingItemOverProperty = DependencyProperty.Register(nameof(IsDraggingItemOver), typeof(bool), typeof(WinoNavigationViewItem), new PropertyMetadata(false, OnIsDraggingItemOverChanged));
-
-    private static void OnIsDraggingItemOverChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
-    {
-        if (obj is WinoNavigationViewItem control)
-            control.UpdateDragEnterState();
-    }
-
-    private void UpdateDragEnterState()
-    {
-        // TODO: Add animation. Maybe after overriding DragUI in shell?
-
-        //if (IsDraggingItemOver)
-        //{
-        //    ScaleAnimation(new System.Numerics.Vector3(1.2f, 1.2f, 1.2f));
-        //}
-        //else
-        //{
-        //    ScaleAnimation(new System.Numerics.Vector3(1f, 1f, 1f));
-        //}
-    }
-
-    private void ScaleAnimation(Vector3 vector)
-    {
-        if (Content is UIElement content)
+        public bool IsDraggingItemOver
        {
-            var visual = ElementCompositionPreview.GetElementVisual(content);
-            visual.Scale = vector;
+            get { return (bool)GetValue(IsDraggingItemOverProperty); }
+            set { SetValue(IsDraggingItemOverProperty, value); }
+        }
+
+        public static readonly DependencyProperty IsDraggingItemOverProperty = DependencyProperty.Register(nameof(IsDraggingItemOver), typeof(bool), typeof(WinoNavigationViewItem), new PropertyMetadata(false, OnIsDraggingItemOverChanged));
+
+        private static void OnIsDraggingItemOverChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
+        {
+            if (obj is WinoNavigationViewItem control)
+                control.UpdateDragEnterState();
+        }
+
+        private void UpdateDragEnterState()
+        {
+            // TODO: Add animation. Maybe after overriding DragUI in shell?
+
+            //if (IsDraggingItemOver)
+            //{
+            //    ScaleAnimation(new System.Numerics.Vector3(1.2f, 1.2f, 1.2f));
+            //}
+            //else
+            //{
+            //    ScaleAnimation(new System.Numerics.Vector3(1f, 1f, 1f));
+            //}
+        }
+
+        private void ScaleAnimation(Vector3 vector)
+        {
+            if (Content is UIElement content)
+            {
+                var visual = ElementCompositionPreview.GetElementVisual(content);
+                visual.Scale = vector;
+            }
        }
    }
 }