Update dependencies (#21 )

* Update dependencies * Minor nit fixes * Fix UTs
Use IOptions instead of IConfigurationManager (#20 )
2026-09-16 05:19:23 +00:00 · 2021-07-10 12:08:43 +03:00 · 2021-06-22 15:48:37 +03:00 · 2021-06-11 13:50:58 +02:00 · 2021-06-07 14:33:54 +02:00 · 2021-06-07 00:34:43 +02:00
40 changed files with 510 additions and 358 deletions
@@ -0,0 +1,63 @@
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
+using Daybreak.Services.Options;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using System;
+
+namespace Daybreak.Tests.Services
+{
+    [TestClass]
+    public class ApplicationConfigurationOptionsManagerTests
+    {
+        private ApplicationConfigurationOptionsManager applicationConfigurationOptionsManager;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            var configurationManagerMock = new Mock<IConfigurationManager>();
+            configurationManagerMock
+                .Setup(u => u.GetConfiguration())
+                .Returns(new ApplicationConfiguration());
+
+            this.applicationConfigurationOptionsManager = new ApplicationConfigurationOptionsManager(configurationManagerMock.Object);
+        }
+
+        [TestMethod]
+        public void GetApplicationConfiguration_ReturnsObject()
+        {
+            var config = this.applicationConfigurationOptionsManager.GetOptions<ApplicationConfiguration>();
+
+            config.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void GetOtherOptions_ThrowsInvalidOperationException()
+        {
+            var action = new Action(() =>
+            {
+                this.applicationConfigurationOptionsManager.GetOptions<object>();
+            });
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+
+        [TestMethod]
+        public void UpdateOptions_OnApplicationConfiguration_Succeeds()
+        {
+            this.applicationConfigurationOptionsManager.UpdateOptions(new ApplicationConfiguration());
+        }
+
+        [TestMethod]
+        public void UpdateOptions_OnOthers_ThrowsInvalidOperationException()
+        {
+            var action = new Action(() =>
+            {
+                this.applicationConfigurationOptionsManager.UpdateOptions(new object());
+            });
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+    }
+}
@@ -4,7 +4,8 @@ using LiteDB;
 using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.IO;
-using WpfExtended.Logging;
+using System.Linq;
+using System.Logging;

 namespace Daybreak.Tests.Services
 {
@@ -37,6 +38,18 @@ namespace Daybreak.Tests.Services
            logger.Should().NotBeNull();
        }
        [TestMethod]
+        public void LoggerLogsAndReaderReadsFiltered()
+        {
+            var logger = this.loggerProvider.CreateLogger("SomeCategory");
+            logger.LogTrace("Logging some trace");
+            logger.LogInformation("Logging some stuff");
+            logger.LogError("Logging some error");
+
+            this.logsManager.GetLogs(l => l.LogLevel < LogLevel.Information).Should().HaveCount(1);
+            var log = this.logsManager.GetLogs(l => l.LogLevel < LogLevel.Information).First();
+            log.LogLevel.Should().Be(LogLevel.Error);
+        }
+        [TestMethod]
        public void LoggerLogsAndReaderReads()
        {
            var logger = this.loggerProvider.CreateLogger("SomeCategory");
@@ -1,5 +1,4 @@
 using Daybreak.Services.ApplicationLauncher;
-using Daybreak.Services.ApplicationLifetime;
 using Daybreak.Services.Bloogum;
 using Daybreak.Services.BuildTemplates;
 using Daybreak.Services.Configuration;
@@ -8,7 +7,6 @@ using Daybreak.Services.IconRetrieve;
 using Daybreak.Services.Logging;
 using Daybreak.Services.Mutex;
 using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.Screens;
 using Daybreak.Services.Screenshots;
 using Daybreak.Services.Shortcuts;
@@ -20,9 +18,9 @@ using Microsoft.Extensions.Logging;
 using Slim;
 using System.Extensions;
 using System.Net.Http;
-using System.Windows.Extensions.Http;
 using LiteDB;
-using System.Windows.Extensions;
+using Daybreak.Services.Options;
+using System.Http;

 namespace Daybreak.Configuration
 {
@@ -41,17 +39,16 @@ namespace Daybreak.Configuration
                    var handler = new LoggingHttpMessageHandler(logger) { InnerHandler = new HttpClientHandler() };
                    return handler;
                }));
+            serviceManager.RegisterOptionsManager<ApplicationConfigurationOptionsManager>();
        }

        public static void RegisterServices(IServiceProducer serviceProducer)
        {
            serviceProducer.ThrowIfNull(nameof(serviceProducer));

-            serviceProducer.RegisterSingleton<ApplicationLifetimeManager>();
            serviceProducer.RegisterSingleton<ViewManager>();
            serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
            serviceProducer.RegisterSingleton<ILiteDatabase, LiteDatabase>(sp => new LiteDatabase("Daybreak.db"));
-            serviceProducer.RegisterSingleton<IRuntimeStore, RuntimeStore>();
            serviceProducer.RegisterSingleton<IMutexHandler, MutexHandler>();
            serviceProducer.RegisterSingleton<IShortcutManager, ShortcutManager>();
            serviceProducer.RegisterScoped<ICredentialManager, CredentialManager>();
@@ -65,14 +62,7 @@ namespace Daybreak.Configuration
            serviceProducer.RegisterScoped<IScreenManager, ScreenManager>();
            serviceProducer.RegisterLogWriter<ILogsManager, JsonLogsManager>();
        }
-        public static void RegisterLifetimeServices(IApplicationLifetimeProducer applicationLifetimeProducer)
-        {
-            applicationLifetimeProducer.ThrowIfNull(nameof(applicationLifetimeProducer));

-            applicationLifetimeProducer.RegisterService<IScreenshotProvider>();
-            applicationLifetimeProducer.RegisterService<IApplicationUpdater>();
-            applicationLifetimeProducer.RegisterService<IShortcutManager>();
-        }
        public static void RegisterViews(IViewProducer viewProducer)
        {
            viewProducer.ThrowIfNull(nameof(viewProducer));
@@ -1,11 +1,12 @@
-using Daybreak.Models.Browser;
+using Daybreak.Configuration;
+using Daybreak.Models.Browser;
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Utils;
 using Microsoft.Extensions.Logging;
 using Microsoft.Web.WebView2.Core;
 using System;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Threading.Tasks;
@@ -22,13 +23,16 @@ namespace Daybreak.Controls
    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
    public partial class ChromiumBrowserWrapper : UserControl
    {
+        public static readonly DependencyProperty AddressProperty =
+            DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, string>(nameof(Address));
+        
        private const string BrowserDownloadLink = "https://developer.microsoft.com/en-us/microsoft-edge/webview2/";

        public event EventHandler<string> FavoriteUriChanged;
        public event EventHandler MaximizeClicked;
        public event EventHandler<Build> BuildDecoded;

-        private IConfigurationManager configurationManager;
+        private ILiveOptions<ApplicationConfiguration> liveOptions;
        private ILogger<ChromiumBrowserWrapper> logger;
        private IBuildTemplateManager buildTemplateManager;
        private CoreWebView2Environment coreWebView2Environment;
@@ -49,8 +53,17 @@ namespace Daybreak.Controls
        private bool navigating;
        [GenerateDependencyProperty]
        private string favoriteAddress;
-        [GenerateDependencyProperty]
-        private string address;
+        public string Address
+        {
+            get => this.GetTypedValue<string>(AddressProperty);
+            set
+            {
+                if (this.BrowserSupported is true)
+                {
+                    this.SetValue(AddressProperty, value);
+                }
+            }
+        }

        public ChromiumBrowserWrapper()
        {
@@ -68,11 +81,11 @@ namespace Daybreak.Controls
        }

        public async void InitializeBrowser(
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            IBuildTemplateManager buildTemplateManager,
            ILogger<ChromiumBrowserWrapper> logger)
        {
-            this.configurationManager = configurationManager;
+            this.liveOptions = liveOptions;
            this.buildTemplateManager = buildTemplateManager;
            this.logger = logger;
            this.InitializeEnvironment();
@@ -86,7 +99,7 @@ namespace Daybreak.Controls

        private void InitializeEnvironment()
        {
-            if (this.configurationManager.GetConfiguration().BrowsersEnabled is false)
+            if (this.liveOptions.Value.BrowsersEnabled is false)
            {
                this.BrowserSupported = false;
                return;
@@ -110,8 +123,8 @@ namespace Daybreak.Controls
            {
                this.WebBrowser.IsEnabled = true;
                await this.WebBrowser.EnsureCoreWebView2Async(this.coreWebView2Environment);
-                this.AddressBarReadonly = this.configurationManager.GetConfiguration().AddressBarReadonly;
-                this.CanDownloadBuild = this.configurationManager.GetConfiguration().ExperimentalFeatures.DynamicBuildLoading;
+                this.AddressBarReadonly = this.liveOptions.Value.AddressBarReadonly;
+                this.CanDownloadBuild = this.liveOptions.Value.ExperimentalFeatures.DynamicBuildLoading;
                this.WebBrowser.CoreWebView2.NewWindowRequested += (browser, args) => args.Handled = true;
                this.WebBrowser.NavigationStarting += (browser, args) =>
                {
@@ -184,6 +197,7 @@ namespace Daybreak.Controls
            {
                this.logger.LogError(e, $"Exception encountered when deserializing {nameof(BrowserPayload)}");
            }
+
            if (payload?.Key == BrowserPayload.PayloadKeys.ContextMenu)
            {
                var contextMenuPayload = args.WebMessageAsJson.Deserialize<BrowserPayload<OnContextMenuPayload>>();
@@ -1,11 +1,12 @@
-using Daybreak.Models.Builds;
+using Daybreak.Configuration;
+using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.IconRetrieve;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
@@ -59,16 +60,16 @@ namespace Daybreak.Controls
        {
            this.InitializeComponent();
            this.InitializeProperties();
-            this.DataContextChanged += BuildTemplate_DataContextChanged;
+            this.DataContextChanged += this.BuildTemplate_DataContextChanged;
        }

        public void InitializeTemplate(
            IIconRetriever iconRetriever,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            IBuildTemplateManager buildTemplateManager,
            ILogger<ChromiumBrowserWrapper> logger)
        {
-            this.SkillBrowser.InitializeBrowser(configurationManager, buildTemplateManager, logger);
+            this.SkillBrowser.InitializeBrowser(liveOptions, buildTemplateManager, logger);
            this.SkillTemplate0.InitializeSkillTemplate(iconRetriever);
            this.SkillTemplate1.InitializeSkillTemplate(iconRetriever);
            this.SkillTemplate2.InitializeSkillTemplate(iconRetriever);
@@ -97,6 +98,7 @@ namespace Daybreak.Controls
                {
                    this.loadedBuild.Build.Secondary = this.SecondaryProfession;
                }
+
                this.LoadSkills();
                this.LoadAttributes();
                if (this.suppressBuildChanged is false)
@@ -192,55 +194,62 @@ namespace Daybreak.Controls
        private void LoadSkills()
        {
            var possibleSkills = Skill.Skills
-                .Where(s => s.Profession == PrimaryProfession || s.Profession == SecondaryProfession || s.Profession == Profession.None)
+                .Where(s => s.Profession == this.PrimaryProfession || s.Profession == this.SecondaryProfession || s.Profession == Profession.None)
                .Where(s => s != Skill.NoSkill)
                .OrderBy(s => s.Name);
            this.AvailableSkills.ClearAnd().AddRange(possibleSkills);

-            if (this.Skill0.Profession != PrimaryProfession &&
-                this.Skill0.Profession != SecondaryProfession &&
+            if (this.Skill0.Profession != this.PrimaryProfession &&
+                this.Skill0.Profession != this.SecondaryProfession &&
                this.Skill0.Profession != Profession.None)
            {
                this.Skill0 = Skill.NoSkill;
            }
-            if (this.Skill1.Profession != PrimaryProfession &&
-                this.Skill1.Profession != SecondaryProfession &&
+
+            if (this.Skill1.Profession != this.PrimaryProfession &&
+                this.Skill1.Profession != this.SecondaryProfession &&
                this.Skill1.Profession != Profession.None)
            {
                this.Skill1 = Skill.NoSkill;
            }
-            if (this.Skill2.Profession != PrimaryProfession &&
-                this.Skill2.Profession != SecondaryProfession &&
+
+            if (this.Skill2.Profession != this.PrimaryProfession &&
+                this.Skill2.Profession != this.SecondaryProfession &&
                this.Skill2.Profession != Profession.None)
            {
                this.Skill2 = Skill.NoSkill;
            }
-            if (this.Skill3.Profession != PrimaryProfession &&
-                this.Skill3.Profession != SecondaryProfession &&
+
+            if (this.Skill3.Profession != this.PrimaryProfession &&
+                this.Skill3.Profession != this.SecondaryProfession &&
                this.Skill3.Profession != Profession.None)
            {
                this.Skill3 = Skill.NoSkill;
            }
-            if (this.Skill4.Profession != PrimaryProfession &&
-                this.Skill4.Profession != SecondaryProfession &&
+
+            if (this.Skill4.Profession != this.PrimaryProfession &&
+                this.Skill4.Profession != this.SecondaryProfession &&
                this.Skill4.Profession != Profession.None)
            {
                this.Skill4 = Skill.NoSkill;
            }
-            if (this.Skill5.Profession != PrimaryProfession &&
-                this.Skill5.Profession != SecondaryProfession &&
+
+            if (this.Skill5.Profession != this.PrimaryProfession &&
+                this.Skill5.Profession != this.SecondaryProfession &&
                this.Skill5.Profession != Profession.None)
            {
                this.Skill5 = Skill.NoSkill;
            }
-            if (this.Skill6.Profession != PrimaryProfession &&
-                this.Skill6.Profession != SecondaryProfession &&
+
+            if (this.Skill6.Profession != this.PrimaryProfession &&
+                this.Skill6.Profession != this.SecondaryProfession &&
                this.Skill6.Profession != Profession.None)
            {
                this.Skill6 = Skill.NoSkill;
            }
-            if (this.Skill7.Profession != PrimaryProfession &&
-                this.Skill7.Profession != SecondaryProfession &&
+
+            if (this.Skill7.Profession != this.PrimaryProfession &&
+                this.Skill7.Profession != this.SecondaryProfession &&
                this.Skill7.Profession != Profession.None)
            {
                this.Skill7 = Skill.NoSkill;
@@ -274,13 +283,19 @@ namespace Daybreak.Controls

        private void ShowInfoBrowser()
        {
-            this.SkillBrowser.Width = 400;
-            this.SkillsListView.Width = 0;
+            if (this.SkillBrowser.BrowserSupported is true)
+            {
+                this.SkillBrowser.Width = 400;
+                this.SkillsListView.Width = 0;
+            }
        }

        private void HideInfoBrowser()
        {
-            this.SkillBrowser.Width = 0;
+            if (this.SkillBrowser.BrowserSupported is true)
+            {
+                this.SkillBrowser.Width = 0;
+            }
        }

        private void ShowSkillListView()
@@ -301,7 +316,7 @@ namespace Daybreak.Controls
                return;
            }

-            this.BrowseToInfo(PrimaryProfession.Name);
+            this.BrowseToInfo(this.PrimaryProfession.Name);
            if (e is RoutedEventArgs routedEventArgs)
            {
                routedEventArgs.Handled = true;
@@ -344,6 +359,7 @@ namespace Daybreak.Controls
            {
                this.BrowseToInfo(skill.Name);
            }
+
            e.Handled = true;
        }

@@ -362,14 +378,14 @@ namespace Daybreak.Controls

            this.selectingSkillTemplate.DataContext = sender.As<ListView>().SelectedItem;
            this.HideSkillListView();
-            this.loadedBuild.Build.Skills[0] = Skill0;
-            this.loadedBuild.Build.Skills[1] = Skill1;
-            this.loadedBuild.Build.Skills[2] = Skill2;
-            this.loadedBuild.Build.Skills[3] = Skill3;
-            this.loadedBuild.Build.Skills[4] = Skill4;
-            this.loadedBuild.Build.Skills[5] = Skill5;
-            this.loadedBuild.Build.Skills[6] = Skill6;
-            this.loadedBuild.Build.Skills[7] = Skill7;
+            this.loadedBuild.Build.Skills[0] = this.Skill0;
+            this.loadedBuild.Build.Skills[1] = this.Skill1;
+            this.loadedBuild.Build.Skills[2] = this.Skill2;
+            this.loadedBuild.Build.Skills[3] = this.Skill3;
+            this.loadedBuild.Build.Skills[4] = this.Skill4;
+            this.loadedBuild.Build.Skills[5] = this.Skill5;
+            this.loadedBuild.Build.Skills[6] = this.Skill6;
+            this.loadedBuild.Build.Skills[7] = this.Skill7;
        }

        private void ListView_NavigateWithMouseWheel(object sender, System.Windows.Input.MouseWheelEventArgs e)
@@ -0,0 +1,18 @@
+<UserControl x:Class="Daybreak.Controls.LogMessageTemplate"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Daybreak.Controls"
+             x:Name="_this"
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800">
+    <UserControl.Resources>
+        <BooleanToVisibilityConverter x:Key="BoolToVisibilityConverter"></BooleanToVisibilityConverter>
+    </UserControl.Resources>
+    <Grid HorizontalAlignment="Stretch">
+        <TextBlock Text="{Binding ElementName=_this, Path=Message, Mode=OneWay}" Background="Transparent"
+                 Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+                 MouseLeftButtonDown="TextBox_MouseLeftButtonDown" MaxHeight="18" TextWrapping="Wrap"></TextBlock>
+    </Grid>
+</UserControl>
@@ -0,0 +1,36 @@
+using System.Windows.Extensions;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Extensions;
+
+namespace Daybreak.Controls
+{
+    /// <summary>
+    /// Interaction logic for LogTemplate.xaml
+    /// </summary>
+    public partial class LogMessageTemplate : UserControl
+    {
+        private bool expanded;
+
+        [GenerateDependencyProperty]
+        private string message;
+
+        public LogMessageTemplate()
+        {
+            this.InitializeComponent();
+        }
+
+        private void TextBox_MouseLeftButtonDown(object sender, MouseButtonEventArgs eventArgs)
+        {
+            this.expanded = !this.expanded;
+            if (this.expanded)
+            {
+                sender.As<TextBlock>().MaxHeight = double.MaxValue;
+            }
+            else
+            {
+                sender.As<TextBlock>().MaxHeight = 18;
+            }
+        }
+    }
+}
@@ -10,7 +10,7 @@
    <LangVersion>preview</LangVersion>
    <ApplicationIcon>Daybreak.ico</ApplicationIcon>
    <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
-    <Version>0.9.2</Version>
+    <Version>0.9.2.5</Version>
  </PropertyGroup>

  <ItemGroup>
@@ -23,11 +23,12 @@
    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    <PackageReference Include="NReco.Logging.File" Version="1.1.1" />
    <PackageReference Include="securifybv.ShellLink" Version="0.1.0" />
-    <PackageReference Include="Slim" Version="1.4.3" />
+    <PackageReference Include="Slim" Version="1.5.1" />
    <PackageReference Include="System.Windows.Interactivity.WPF" Version="2.0.20525" />
    <PackageReference Include="SystemExtensions.NetStandard" Version="1.3.0" />
+    <PackageReference Include="SystemExtensions.NetStandard.DependencyInjection" Version="1.1.0" />
    <PackageReference Include="WCL" Version="1.0.2" />
-    <PackageReference Include="WpfExtended" Version="0.4.1" />
+    <PackageReference Include="WpfExtended" Version="0.6.0" />
    <PackageReference Include="WpfExtended.SourceGeneration" Version="0.1.1" />
    <PackageReference Include="WpfScreenHelper" Version="1.0.0" />
  </ItemGroup>
@@ -1,6 +1,5 @@
 using Daybreak.Configuration;
 using Daybreak.Exceptions;
-using Daybreak.Services.ApplicationLifetime;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using Slim;
@@ -16,7 +15,7 @@ namespace Daybreak.Launch
 {
    public sealed class Launcher : ExtendedApplication<MainWindow>
    {
-        public static IServiceManager ApplicationServiceManager { get; private set; }
+        private ILogger logger;
        private readonly static Launcher launcher = new();

        [STAThread]
@@ -27,14 +26,12 @@ namespace Daybreak.Launch

        protected override void SetupServiceManager(IServiceManager serviceManager)
        {
-            ApplicationServiceManager = this.ServiceManager;
            ProjectConfiguration.RegisterResolvers(serviceManager);
        }
        protected override void RegisterServices(IServiceProducer serviceProducer)
        {
            ProjectConfiguration.RegisterServices(this.ServiceManager);
            ServiceManager.BuildSingletons();
-            ProjectConfiguration.RegisterLifetimeServices(this.ServiceManager.GetService<IApplicationLifetimeManager>());
            ProjectConfiguration.RegisterViews(this.ServiceManager.GetService<IViewManager>());
        }
        protected override bool HandleException(Exception e)
@@ -44,17 +41,16 @@ namespace Daybreak.Launch
                return false;
            }

-            this.ServiceManager.GetService<ILogger>().LogCritical(e, $"Unhandled exception");
            if (e is FatalException fatalException)
            {
-                this.ServiceManager.GetService<ILogger>().LogCritical(e, $"{nameof(FatalException)} encountered. Closing application.");
+                this.logger.LogCritical(e, $"{nameof(FatalException)} encountered. Closing application");
                MessageBox.Show(fatalException.ToString());
                File.WriteAllText("crash.log", e.ToString());
                return false;
            }
            else if (e is TargetInvocationException targetInvocationException && e.InnerException is FatalException innerFatalException)
            {
-                this.ServiceManager.GetService<ILogger>().LogCritical(e, $"{nameof(FatalException)} encountered. Closing application.");
+                this.logger.LogCritical(e, $"{nameof(FatalException)} encountered. Closing application");
                MessageBox.Show(innerFatalException.ToString());
                File.WriteAllText("crash.log", e.ToString());
                return false;
@@ -66,23 +62,33 @@ namespace Daybreak.Launch
                {
                    /* 
                     * Ignore exception caused by browser failing to initialize due to missing window.
-                     * Likely caused by switching windows before browser was initialized.
+                     * Likely caused by switching views before browser was initialized.
                     */
+                    this.logger.LogError(e, "Failed to initialize browser");
                    return true;
                }
            }
+            else if (e.Message.Contains("Invalid window handle.") && e.StackTrace.Contains("CoreWebView2Environment.CreateCoreWebView2ControllerAsync"))
+            {
+                /*
+                 * Ignore exception caused by browser failing to initialize due to missing window.
+                 * Likely caused by switching views before the browser was initialized.
+                 */
+                this.logger.LogError(e, "Failed to initialize browser");
+                return true;
+            }

+            this.logger.LogError(e, $"Unhandled exception caught {e.GetType()}");
            MessageBox.Show(e.ToString());
            return true;
        }
        protected override void ApplicationStarting()
        {
-            this.ServiceManager.GetService<IApplicationLifetimeManager>().OnStartup();
+            this.logger = this.ServiceManager.GetService<ILogger<Launcher>>();
            this.RegisterViewContainer();
        }
        protected override void ApplicationClosing()
        {
-            this.ServiceManager.GetService<IApplicationLifetimeManager>().OnClosing();
        }

        private void RegisterViewContainer()
@@ -1,13 +1,13 @@
-using Daybreak.Services.Bloogum;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Services.Bloogum;
 using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.Screenshots;
 using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Pepa.Wpf.Utilities;
 using System;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Threading;
@@ -32,11 +32,9 @@ namespace Daybreak.Launch
        private readonly IBloogumClient bloogumClient;
        private readonly IApplicationUpdater applicationUpdater;
        private readonly IPrivilegeManager privilegeManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
        private readonly CancellationTokenSource cancellationToken = new();

-        private bool canCheckUpdate = false;
-
        [GenerateDependencyProperty]
        private string creditText;
        [GenerateDependencyProperty]
@@ -50,26 +48,19 @@ namespace Daybreak.Launch
            IBloogumClient bloogumClient,
            IApplicationUpdater applicationUpdater,
            IPrivilegeManager privilegeManager,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
        {
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.screenshotProvider = screenshotProvider.ThrowIfNull(nameof(screenshotProvider));
            this.bloogumClient = bloogumClient.ThrowIfNull(nameof(bloogumClient));
            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
            this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.InitializeComponent();
-            this.LoadConfiguration();
-            this.configurationManager.ConfigurationChanged += (s, e) => this.LoadConfiguration();
            this.CurrentVersionText = this.applicationUpdater.CurrentVersion.ToString();
            this.IsRunningAsAdmin = this.privilegeManager.AdminPrivileges;
        }

-        private void LoadConfiguration()
-        {
-            var configuration = this.configurationManager.GetConfiguration();
-            this.canCheckUpdate = configuration.AutoCheckUpdate;
-        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
@@ -178,7 +169,7 @@ namespace Daybreak.Launch

        private async void CheckForUpdates()
        {
-            var updateAvailable = this.canCheckUpdate is true && await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
+            var updateAvailable = this.liveOptions.Value.AutoCheckUpdate is true && await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
            if (updateAvailable)
            {
                this.viewManager.ShowView<AskUpdateView>();
@@ -0,0 +1,15 @@
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Daybreak.Models
+{
+    public sealed class Log
+    {
+        public string Message { get; set; }
+        public string Category { get; set; }
+        public LogLevel LogLevel { get; set; }
+        public string CorrelationVector { get; set; }
+        public string EventId { get; set; }
+        public DateTime LogTime { get; set; }
+    }
+}
@@ -1,5 +1,5 @@
-using Daybreak.Exceptions;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Exceptions;
 using Daybreak.Services.Credentials;
 using Daybreak.Services.Mutex;
 using Daybreak.Services.Privilege;
@@ -9,6 +9,7 @@ using Microsoft.Win32;
 using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.IO;
@@ -29,7 +30,7 @@ namespace Daybreak.Services.ApplicationLauncher
        private const string ProcessName = "gw";
        private const string ArenaNetMutex = "AN-Mute";

-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
        private readonly ICredentialManager credentialManager;
        private readonly IMutexHandler mutexHandler;
        private readonly ILogger<ApplicationLauncher> logger;
@@ -40,7 +41,7 @@ namespace Daybreak.Services.ApplicationLauncher
        public bool IsToolboxRunning => GuildwarsToolboxProcessDetected();

        public ApplicationLauncher(
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            ICredentialManager credentialManager,
            IMutexHandler mutexHandler,
            ILogger<ApplicationLauncher> logger,
@@ -49,13 +50,13 @@ namespace Daybreak.Services.ApplicationLauncher
            this.logger = logger.ThrowIfNull(nameof(logger));
            this.mutexHandler = mutexHandler.ThrowIfNull(nameof(mutexHandler));
            this.credentialManager = credentialManager.ThrowIfNull(nameof(credentialManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
        }

        public async Task<bool> LaunchGuildwars()
        {
-            var configuration = this.configurationManager.GetConfiguration();
+            var configuration = this.liveOptions.Value;
            var auth = await this.credentialManager.GetDefaultCredentials().ConfigureAwait(false);
            return await auth.Switch(
                onSome: async (credentials) =>
@@ -68,10 +69,10 @@ namespace Daybreak.Services.ApplicationLauncher
                            return false;
                        }

-                        ClearGwLocks();
+                        this.ClearGwLocks();
                    }

-                    return await LaunchGuildwarsProcess(credentials.Username, credentials.Password, credentials.CharacterName);
+                    return await this.LaunchGuildwarsProcess(credentials.Username, credentials.Password, credentials.CharacterName);
                },
                onNone: () =>
                {
@@ -84,7 +85,7 @@ namespace Daybreak.Services.ApplicationLauncher
        {
            return Task.Run(() =>
            {
-                var configuration = this.configurationManager.GetConfiguration();
+                var configuration = this.liveOptions.Value;
                var executable = configuration.ToolboxPath;
                if (File.Exists(executable) is false)
                {
@@ -102,7 +103,7 @@ namespace Daybreak.Services.ApplicationLauncher
        {
            return Task.Run(() =>
            {
-                var configuration = this.configurationManager.GetConfiguration();
+                var configuration = this.liveOptions.Value;
                var executable = configuration.TexmodPath;
                if (File.Exists(executable) is false)
                {
@@ -145,7 +146,7 @@ namespace Daybreak.Services.ApplicationLauncher

        private async Task<bool> LaunchGuildwarsProcess(string email, Models.SecureString password, string character)
        {
-            var executable = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+            var executable = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
            if (executable is null)
            {
                throw new ExecutableNotFoundException($"No executable selected");
@@ -169,7 +170,7 @@ namespace Daybreak.Services.ApplicationLauncher
                args.Add(character);
            }

-            var identity = this.configurationManager.GetConfiguration().ExperimentalFeatures.LaunchGuildwarsAsCurrentUser ?
+            var identity = this.liveOptions.Value.ExperimentalFeatures.LaunchGuildwarsAsCurrentUser ?
                System.Security.Principal.WindowsIdentity.GetCurrent().Name :
                System.Security.Principal.WindowsIdentity.GetAnonymous().Name;
            this.logger.LogInformation($"Launching guildwars as [{identity}] identity");
@@ -221,11 +222,11 @@ namespace Daybreak.Services.ApplicationLauncher

        private bool GuildwarsProcessDetected()
        {
-            if (this.configurationManager.GetConfiguration().ExperimentalFeatures.MultiLaunchSupport is true)
+            if (this.liveOptions.Value.ExperimentalFeatures.MultiLaunchSupport is true)
            {
                try
                {
-                    var path = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+                    var path = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
                    if (path is null)
                    {
                        return false;
@@ -253,7 +254,7 @@ namespace Daybreak.Services.ApplicationLauncher

        private void SetRegistryGuildwarsPath()
        {
-            var path = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+            var path = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
            if (path is null)
            {
                throw new ExecutableNotFoundException("No executable currently selected");
@@ -1,43 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Extensions;
-using IServiceProvider = Slim.IServiceProvider;
-
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public sealed class ApplicationLifetimeManager : IApplicationLifetimeManager
-    {
-        private readonly IServiceProvider serviceProvider;
-        private List<Type> RegisteredTypes { get; } = new List<Type>();
-
-        public ApplicationLifetimeManager(IServiceProvider serviceProvider)
-        {
-            serviceProvider.ThrowIfNull(nameof(serviceProvider));
-
-            this.serviceProvider = serviceProvider;
-        }
-
-        public void RegisterService<T>() where T : IApplicationLifetimeService
-        {
-            this.RegisteredTypes.Add(typeof(T));
-        }
-
-        public void OnStartup()
-        {
-            foreach (var serviceType in this.RegisteredTypes)
-            {
-                var service = this.serviceProvider.GetService(serviceType);
-                service.As<IApplicationLifetimeService>().OnStartup();
-            }
-        }
-
-        public void OnClosing()
-        {
-            foreach (var serviceType in this.RegisteredTypes)
-            {
-                var service = this.serviceProvider.GetService(serviceType);
-                service.As<IApplicationLifetimeService>().OnClosing();
-            }
-        }
-    }
-}
@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeManager : IApplicationLifetimeProducer
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}
@@ -1,7 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeProducer
-    {
-        void RegisterService<T>() where T : IApplicationLifetimeService;
-    }
-}
@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeService
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}
@@ -1,8 +1,9 @@
-using Daybreak.Models;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Security.Cryptography;
@@ -15,13 +16,13 @@ namespace Daybreak.Services.Credentials
    {
        private static readonly byte[] Entropy = Convert.FromBase64String("R3VpbGR3YXJz");
        private readonly ILogger<CredentialManager> logger;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;

        public CredentialManager(
            ILogger<CredentialManager> logger,
-            IConfigurationManager configurationManager)
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions)
        {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.logger = logger.ThrowIfNull(nameof(logger));
        }

@@ -53,7 +54,7 @@ namespace Daybreak.Services.Credentials
            return Task.Run(() =>
            {
                this.logger.LogInformation("Retrieving credentials");
-                var config = this.configurationManager.GetConfiguration();
+                var config = this.liveOptions.Value;
                if (config.ProtectedLoginCredentials is null || config.ProtectedLoginCredentials.Count == 0)
                {
                    this.logger.LogInformation("No credentials found");
@@ -62,9 +63,9 @@ namespace Daybreak.Services.Credentials

                return config
                    .ProtectedLoginCredentials
-                    .Select(UnprotectCredentials)
-                    .Where(CredentialsUnprotected)
-                    .Select(ExtractCredentials)
+                    .Select(this.UnprotectCredentials)
+                    .Where(this.CredentialsUnprotected)
+                    .Select(this.ExtractCredentials)
                    .ToList();
            });
        }
@@ -73,13 +74,12 @@ namespace Daybreak.Services.Credentials
            return Task.Run(() =>
            {
                this.logger.LogInformation("Storing credentials");
-                var config = this.configurationManager.GetConfiguration();
-                config.ProtectedLoginCredentials = loginCredentials
-                    .Select(ProtectCredentials)
-                    .Where(CredentialsProtected)
-                    .Select(ExtractProtectedCredentials)
+                this.liveOptions.Value.ProtectedLoginCredentials = loginCredentials
+                    .Select(this.ProtectCredentials)
+                    .Where(this.CredentialsProtected)
+                    .Select(this.ExtractProtectedCredentials)
                    .ToList();
-                this.configurationManager.SaveConfiguration(config);
+                this.liveOptions.UpdateOption();
            });   
        }

@@ -1,8 +1,9 @@
-using Daybreak.Models.Builds;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models.Builds;
 using HtmlAgilityPack;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Http;
 using System.IO;
@@ -21,16 +22,16 @@ namespace Daybreak.Services.IconRetrieve

        private readonly IHttpClient<IconRetriever> httpClient;
        private readonly ILogger<IconRetriever> logger;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;

        public IconRetriever(
            ILogger<IconRetriever> logger,
            IHttpClient<IconRetriever> httpClient,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
        {
            this.logger = logger.ThrowIfNull(nameof(logger));
            this.httpClient = httpClient.ThrowIfNull(nameof(httpClient));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.httpClient.BaseAddress = new Uri(BaseUrl);
            if (Directory.Exists(IconsDirectoryName) is false)
            {
@@ -40,7 +41,7 @@ namespace Daybreak.Services.IconRetrieve

        public async Task<Optional<Stream>> GetIcon(Skill skill)
        {
-            if (this.configurationManager.GetConfiguration().KeepLocalIconCache)
+            if (this.liveOptions.Value.KeepLocalIconCache)
            {
                this.logger.LogInformation($"{nameof(IconRetriever)} configured to look first in cache before downloading icons");
                var maybeIcon = await this.GetLocalIcon(skill);
@@ -86,10 +87,11 @@ namespace Daybreak.Services.IconRetrieve
            {
                this.logger.LogInformation("Retrieved latest icon stream");
                var iconData = await iconResponse.Content.ReadAsByteArrayAsync();
-                if (this.configurationManager.GetConfiguration().KeepLocalIconCache)
+                if (this.liveOptions.Value.KeepLocalIconCache)
                {
-                    await this.SaveIconLocally(skill, iconData);
+                    await SaveIconLocally(skill, iconData);
                }
+
                return new MemoryStream(iconData);
            }

@@ -113,7 +115,7 @@ namespace Daybreak.Services.IconRetrieve
            return Optional.None<Stream>();
        }

-        private async Task SaveIconLocally(Skill skill, byte[] data)
+        private static async Task SaveIconLocally(Skill skill, byte[] data)
        {
            var curedSkillName = skill.Name
                .Replace(" ", "_")
@@ -1,6 +1,6 @@
 using Daybreak.Models;
-using Daybreak.Services.ApplicationLifetime;
 using System;
+using System.Windows.Extensions.Services;

 namespace Daybreak.Services.KeyboardHook
 {
@@ -1,4 +1,4 @@
-using Daybreak.Services.ApplicationLifetime;
+using System.Windows.Extensions.Services;

 namespace Daybreak.Services.KeyboardMacros
 {
@@ -1,10 +1,10 @@
-using Daybreak.Models;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models;
 using Daybreak.Services.KeyboardHook;
-using Microsoft.Extensions.Logging;
 using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Text;
@@ -17,32 +17,23 @@ namespace Daybreak.Services.KeyboardMacros
    {
        private readonly CancellationTokenSource cancellationTokenSource = new();
        private readonly IKeyboardHookService keyboardHookService;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
        private readonly HashSet<Keys> KeysDown = new();

-        private IEnumerable<KeyMacro> loadedMacros;
-        private bool gameActive, hookEnabled;
+        private bool gameActive;
        private IntPtr gwWindowHwnd;

        public MacroService(
            IKeyboardHookService keyboardHookService,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
        {
            this.keyboardHookService = keyboardHookService.ThrowIfNull(nameof(keyboardHookService));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));

-            this.configurationManager.ConfigurationChanged += (s, e) => this.LoadConfiguration();
-            this.LoadConfiguration();
            this.keyboardHookService.KeyboardPressed += this.KeyboardHookService_KeyboardPressed;
            this.SetupGameActiveChecker();
        }

-        private void LoadConfiguration()
-        {
-            this.hookEnabled = this.configurationManager.GetConfiguration().ExperimentalFeatures.CanInterceptKeys;
-            this.loadedMacros = this.configurationManager.GetConfiguration().ExperimentalFeatures.Macros ?? new List<KeyMacro>();
-        }
-
        private void SetupGameActiveChecker()
        {
            TaskExtensions.RunPeriodicAsync(() =>
@@ -62,12 +53,12 @@ namespace Daybreak.Services.KeyboardMacros
            },
            TimeSpan.Zero,
            TimeSpan.FromMilliseconds(33),
-            cancellationTokenSource.Token);
+            this.cancellationTokenSource.Token);
        }

        private void KeyboardHookService_KeyboardPressed(object sender, KeyboardHookEventArgs e)
        {
-            if (this.gameActive && this.hookEnabled)
+            if (this.gameActive && this.liveOptions.Value.ExperimentalFeatures.CanInterceptKeys)
            {
                if (e.KeyboardState == KeyboardState.KeyDown)
                {
@@ -79,7 +70,7 @@ namespace Daybreak.Services.KeyboardMacros
                    return;
                }

-                e.Handled = this.loadedMacros
+                e.Handled = this.liveOptions.Value.ExperimentalFeatures.Macros
                    .Where(keyMacro => MacroContainsKey(keyMacro, e.KeyboardInput.Key))
                    .Where(this.MacroHit)
                    .Do(this.HandleMacro)
@@ -1,12 +1,15 @@
-using System.Collections.Generic;
-using WpfExtended.Logging;
-using WpfExtended.Models;
+using Daybreak.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Logging;

 namespace Daybreak.Services.Logging
 {
    public interface ILogsManager : ILogsWriter
    {
-        IEnumerable<Log> GetLogs();
+        IEnumerable<Models.Log> GetLogs(Expression<Func<Models.Log, bool>> filter);
+        IEnumerable<Models.Log> GetLogs();
        int DeleteLogs();
    }
 }
@@ -1,7 +1,9 @@
 using LiteDB;
+using System;
 using System.Collections.Generic;
 using System.Extensions;
-using WpfExtended.Models;
+using System.Linq.Expressions;
+using System.Logging;

 namespace Daybreak.Services.Logging
 {
@@ -14,17 +16,31 @@ namespace Daybreak.Services.Logging
            this.liteDatabase = liteDatabase.ThrowIfNull(nameof(liteDatabase));
        }

-        public IEnumerable<Log> GetLogs()
+        public IEnumerable<Models.Log> GetLogs(Expression<Func<Models.Log, bool>> filter)
        {
-            return this.liteDatabase.GetCollection<Log>().FindAll();
+            return this.liteDatabase.GetCollection<Models.Log>().Find(filter);
+        }
+        public IEnumerable<Models.Log> GetLogs()
+        {
+            return this.liteDatabase.GetCollection<Models.Log>().FindAll();
        }
        public void WriteLog(Log log)
        {
-            this.liteDatabase.GetCollection<Log>().Insert(log);
+            var dbLog = new Models.Log
+            {
+                EventId = log.EventId,
+                Message = log.Exception is null ? log.Message : $"{log.Message}{Environment.NewLine}{log.Exception}",
+                Category = log.Category,
+                LogLevel = log.LogLevel,
+                LogTime = log.LogTime,
+                CorrelationVector = log.CorrelationVector
+            };
+
+            this.liteDatabase.GetCollection<Models.Log>().Insert(dbLog);
        }
        public int DeleteLogs()
        {
-            return this.liteDatabase.GetCollection<Log>().DeleteAll();
+            return this.liteDatabase.GetCollection<Models.Log>().DeleteAll();
        }
    }
 }
@@ -0,0 +1,39 @@
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
+using System;
+using System.Configuration;
+using System.Extensions;
+
+namespace Daybreak.Services.Options
+{
+    public sealed class ApplicationConfigurationOptionsManager : IOptionsManager
+    {
+        private readonly IConfigurationManager configurationManager;
+
+        public ApplicationConfigurationOptionsManager(IConfigurationManager configurationManager)
+        {
+            this.configurationManager = configurationManager;
+        }
+
+        public T GetOptions<T>() where T : class
+        {
+            if (typeof(T) == typeof(ApplicationConfiguration))
+            {
+                return this.configurationManager.GetConfiguration().Cast<T>();
+            }
+
+            throw new InvalidOperationException($"{nameof(ApplicationConfigurationOptionsManager)} cannot return options of type {typeof(T).Name}");
+        }
+
+        public void UpdateOptions<T>(T value) where T : class
+        {
+            if (typeof(T) == typeof(ApplicationConfiguration))
+            {
+                this.configurationManager.SaveConfiguration(value.Cast<ApplicationConfiguration>());
+                return;
+            }
+
+            throw new InvalidOperationException($"{nameof(ApplicationConfigurationOptionsManager)} cannot save options of type {typeof(T).Name}");
+        }
+    }
+}
@@ -1,9 +0,0 @@
-namespace Daybreak.Services.Runtime
-{
-    public interface IRuntimeStore
-    {
-        void StoreValue<T>(string name, T value);
-        bool TryGetValue<T>(string name, out T value);
-        T GetValue<T>(string name);
-    }
-}
@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Extensions;
-
-namespace Daybreak.Services.Runtime
-{
-    public sealed class RuntimeStore : IRuntimeStore
-    {
-        private Dictionary<string, object> InnerStore { get; } = new Dictionary<string, object>();
-
-        public T GetValue<T>(string name)
-        {
-            if(this.InnerStore.TryGetValue(name, out var value))
-            {
-                return value.Cast<T>();
-            }
-
-            throw new InvalidOperationException($"Could not find any value stored with name {name}");
-        }
-        public void StoreValue<T>(string name, T value)
-        {
-            this.InnerStore[name] = value;
-        }
-        public bool TryGetValue<T>(string name, out T value)
-        {
-            if (this.InnerStore.TryGetValue(name, out var valueObj))
-            {
-                value = valueObj.Cast<T>();
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-    }
-}
@@ -1,5 +1,5 @@
-using Daybreak.Services.ApplicationLifetime;
-using System.Extensions;
+using System.Extensions;
+using System.Windows.Extensions.Services;
 using System.Windows.Media;

 namespace Daybreak.Services.Screenshots
@@ -1,4 +1,4 @@
-using Daybreak.Services.ApplicationLifetime;
+using System.Windows.Extensions.Services;

 namespace Daybreak.Services.Shortcuts
 {
@@ -1,16 +1,20 @@
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
 using ShellLink;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.IO;

 namespace Daybreak.Services.Shortcuts
 {
+    //TODO: Fix dependency on IConfigurationManager
    public sealed class ShortcutManager : IShortcutManager
    {
        private const string ShortcutName = "Daybreak.lnk";

        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;

        public bool ShortcutEnabled {
            get => this.ShortcutExists();
@@ -27,16 +31,19 @@ namespace Daybreak.Services.Shortcuts
            }
        }

-        public ShortcutManager(IConfigurationManager configurationManager)
+        public ShortcutManager(
+            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions)
        {
            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.configurationManager.ConfigurationChanged += (_, _) => this.LoadConfiguration();
            this.LoadConfiguration();
        }

        private void LoadConfiguration()
        {
-            var shortcutEnabled = this.configurationManager.GetConfiguration().PlaceShortcut;
+            var shortcutEnabled = this.liveOptions.Value.PlaceShortcut;
            if (shortcutEnabled && this.ShortcutEnabled is false)
            {
                this.ShortcutEnabled = true;
@@ -49,7 +56,7 @@ namespace Daybreak.Services.Shortcuts

        private bool ShortcutExists()
        {
-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
            var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
            if (File.Exists(shortcutPath))
            {
@@ -73,7 +80,7 @@ namespace Daybreak.Services.Shortcuts
                return;
            }

-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
            var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
            var currentExecutable = Process.GetCurrentProcess()?.MainModule?.FileName;
            var shortcut = Shortcut.CreateShortcut(currentExecutable);
@@ -92,7 +99,7 @@ namespace Daybreak.Services.Shortcuts
                return;
            }

-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
            var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
            File.Delete(shortcutPath);
        }
@@ -1,7 +1,7 @@
-using Daybreak.Exceptions;
+using Daybreak.Configuration;
+using Daybreak.Exceptions;
 using Daybreak.Models;
 using Daybreak.Models.Github;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Utils;
 using Daybreak.Views;
@@ -9,6 +9,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Win32;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Http;
@@ -26,7 +27,6 @@ namespace Daybreak.Services.Updater
    public sealed class ApplicationUpdater : IApplicationUpdater
    {
        private const string LaunchActionName = "Launch_Daybreak";
-        private const string UpdateDesiredKey = "UpdateDesired";
        private const string ExecutionPolicyKey = "ExecutionPolicy";
        private const string UpdatedKey = "Updating";
        private const string RegistryKey = "Daybreak";
@@ -59,19 +59,19 @@ namespace Daybreak.Services.Updater
        private readonly CancellationTokenSource updateCancellationTokenSource = new();
        private readonly ILogger<ApplicationUpdater> logger;
        private readonly IViewManager viewManager;
-        private readonly IRuntimeStore runtimeStore;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
        private readonly IHttpClient<ApplicationUpdater> httpClient;

        public Version CurrentVersion { get; }

        public ApplicationUpdater(
            ILogger<ApplicationUpdater> logger,
-            IRuntimeStore runtimeStore,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            IViewManager viewManager,
            IHttpClient<ApplicationUpdater> httpClient)
        {
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.runtimeStore = runtimeStore.ThrowIfNull(nameof(runtimeStore));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.logger = logger.ThrowIfNull(nameof(logger));
            this.httpClient = httpClient.ThrowIfNull(nameof(httpClient));
            this.httpClient.DefaultRequestHeaders.Add("user-agent", "Daybreak Client");
@@ -176,7 +176,7 @@ namespace Daybreak.Services.Updater
        {
            System.Extensions.TaskExtensions.RunPeriodicAsync(async () =>
            {
-                if (this.runtimeStore.TryGetValue<bool>(UpdateDesiredKey, out var desiringUpdate) && desiringUpdate is false)
+                if (this.liveOptions.Value.AutoCheckUpdate is false)
                {
                    this.updateCancellationTokenSource.Cancel();
                    return;
@@ -1,8 +1,8 @@
 using Daybreak.Models;
 using Daybreak.Models.Versioning;
-using Daybreak.Services.ApplicationLifetime;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using System.Windows.Extensions.Services;

 namespace Daybreak.Services.Updater
 {
@@ -1,8 +1,9 @@
-using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
+using Daybreak.Configuration;
+using Daybreak.Services.Privilege;
 using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows.Controls;
@@ -14,24 +15,22 @@ namespace Daybreak.Views
    /// </summary>
    public partial class AskUpdateView : UserControl
    {
-        private const string UpdateDesiredKey = "UpdateDesired";
-
        private readonly ILogger<AskUpdateView> logger;
        private readonly IViewManager viewManager;
-        private readonly IRuntimeStore runtimeStore;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
        private readonly IPrivilegeManager privilegeManager;
        private readonly IApplicationUpdater applicationUpdater;

        public AskUpdateView(
            ILogger<AskUpdateView> logger,
            IViewManager viewManager,
-            IRuntimeStore runtimeStore,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions,
            IPrivilegeManager privilegeManager,
            IApplicationUpdater applicationUpdater)
        {
            this.logger = logger.ThrowIfNull(nameof(logger));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.runtimeStore = runtimeStore.ThrowIfNull(nameof(runtimeStore));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
            this.InitializeComponent();
@@ -51,14 +50,14 @@ namespace Daybreak.Views
        private void NoButton_Clicked(object sender, System.EventArgs e)
        {
            this.logger.LogInformation("User declined update");
-            this.runtimeStore.StoreValue(UpdateDesiredKey, false);
+            this.liveOptions.Value.AutoCheckUpdate = false;
+            this.liveOptions.UpdateOption();
            this.viewManager.ShowView<MainView>();
        }

        private async void YesButton_Clicked(object sender, System.EventArgs e)
        {
            this.logger.LogInformation("User accepted update");
-            this.runtimeStore.StoreValue(UpdateDesiredKey, true);
            if (this.CheckIfAdmin() is false)
            {
                return;
@@ -1,17 +1,17 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.IconRetrieve;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
-using System.Windows.Input;

 namespace Daybreak.Views
 {
@@ -39,7 +39,7 @@ namespace Daybreak.Views
            IViewManager viewManager,
            IBuildTemplateManager buildTemplateManager,
            IIconRetriever iconRetriever,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            ILogger<ChromiumBrowserWrapper> chromiumLogger,
            ILogger<BuildTemplateView> logger)
        {
@@ -47,7 +47,7 @@ namespace Daybreak.Views
            this.logger = logger.ThrowIfNull(nameof(logger));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.InitializeComponent();
-            this.BuildTemplate.InitializeTemplate(iconRetriever, configurationManager, buildTemplateManager, chromiumLogger);
+            this.BuildTemplate.InitializeTemplate(iconRetriever, liveOptions, buildTemplateManager, chromiumLogger);
            this.DataContextChanged += (sender, contextArgs) =>
            {
                if (contextArgs.NewValue is BuildEntry)
@@ -1,10 +1,10 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Models;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.ViewManagement;
-using Microsoft.Win32;
 using System;
 using System.Collections.ObjectModel;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows.Controls;
@@ -17,15 +17,15 @@ namespace Daybreak.Views
    /// </summary>
    public partial class ExecutablesView : UserControl
    {
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;
        private readonly IViewManager viewManager;
        public ObservableCollection<GuildwarsPath> Paths { get; } = new();

        public ExecutablesView(
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions,
            IViewManager viewManager)
        {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.InitializeComponent();
            this.GetPaths();
@@ -33,7 +33,7 @@ namespace Daybreak.Views

        private void GetPaths()
        {
-            this.Paths.AddRange(this.configurationManager.GetConfiguration().GuildwarsPaths);
+            this.Paths.AddRange(this.liveUpdateableOptions.Value.GuildwarsPaths);
        }

        private void BackButton_Clicked(object sender, EventArgs e)
@@ -53,9 +53,8 @@ namespace Daybreak.Views

        private void SaveButton_Clicked(object sender, EventArgs e)
        {
-            var config = this.configurationManager.GetConfiguration();
-            config.GuildwarsPaths = this.Paths.ToList();
-            this.configurationManager.SaveConfiguration(config);
+            this.liveUpdateableOptions.Value.GuildwarsPaths = this.Paths.ToList();
+            this.liveUpdateableOptions.UpdateOption();
            this.viewManager.ShowView<SettingsCategoryView>();
        }

@@ -81,6 +80,7 @@ namespace Daybreak.Views
            {
                path.Default = false;
            }
+
            gwPath.Default = true;
            var view = CollectionViewSource.GetDefaultView(this.Paths);
            view.Refresh();
@@ -1,6 +1,7 @@
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
 using Daybreak.Services.ViewManagement;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
@@ -27,7 +28,7 @@ namespace Daybreak.Views
            DependencyPropertyExtensions.Register<ExperimentalSettingsView, bool>(nameof(MacrosEnabled));

        private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;

        public bool LaunchAsCurrentUser
        {
@@ -57,17 +58,17 @@ namespace Daybreak.Views

        public ExperimentalSettingsView(
            IViewManager viewManager,
-            IConfigurationManager configurationManager)
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions)
        {
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
            this.InitializeComponent();
            this.LoadExperimentalSettings();
        }

        private void LoadExperimentalSettings()
        {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
            this.MultiLaunch = config.ExperimentalFeatures.MultiLaunchSupport;
            this.GWToolboxLaunchDelay = config.ExperimentalFeatures.ToolboxAutoLaunchDelay.ToString();
            this.DynamicBuildLoading = config.ExperimentalFeatures.DynamicBuildLoading;
@@ -77,7 +78,7 @@ namespace Daybreak.Views

        private void SaveExperimentalSettings()
        {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
            config.ExperimentalFeatures.MultiLaunchSupport = this.MultiLaunch;
            config.ExperimentalFeatures.DynamicBuildLoading = this.DynamicBuildLoading;
            config.ExperimentalFeatures.LaunchGuildwarsAsCurrentUser = this.LaunchAsCurrentUser;
@@ -87,7 +88,7 @@ namespace Daybreak.Views
                config.ExperimentalFeatures.ToolboxAutoLaunchDelay = gwToolboxLaunchDelay;
            }

-            this.configurationManager.SaveConfiguration(config);
+            this.liveUpdateableOptions.UpdateOption();
        }

        private void SaveButton_Clicked(object sender, EventArgs e)
@@ -24,6 +24,12 @@
                            Clicked="BinButton_Clicked"></controls:BinButton>
        <controls:RefreshGlyph Foreground="White" Height="30" Width="30" HorizontalAlignment="Right" Margin="0, 5, 45, 5"
                               Clicked="RefreshGlyph_Clicked"></controls:RefreshGlyph>
+        <controls:BackButton Foreground="White" Height="30" Width="30" HorizontalAlignment="Right" Margin="0, 5, 85, 5"
+                             Clicked="ExportButton_Clicked">
+            <controls:BackButton.RenderTransform>
+                <RotateTransform Angle="270" CenterX="15" CenterY="15"></RotateTransform>
+            </controls:BackButton.RenderTransform>
+        </controls:BackButton>
        <DataGrid IsReadOnly="True" Background="Transparent" Foreground="White" Grid.Row="1"
                  ItemsSource="{Binding ElementName=_this, Path=Logs, Mode=OneWay}" HorizontalScrollBarVisibility="Disabled"
                  AutoGenerateColumns="False" HeadersVisibility="Column" EnableColumnVirtualization="True"
@@ -54,7 +60,13 @@
                <DataGridTextColumn IsReadOnly="True" Header="Category" Binding="{Binding Category}" ElementStyle="{StaticResource WrapText}" Width="auto"/>
                <DataGridTextColumn IsReadOnly="True" Header="LogLevel" Binding="{Binding LogLevel}" ElementStyle="{StaticResource WrapText}" Width="auto"/>
                <DataGridTextColumn IsReadOnly="True" Header="EventId" Binding="{Binding EventId}" ElementStyle="{StaticResource WrapText}" Width="auto"/>
-                <DataGridTextColumn IsReadOnly="True" Header="Message" Binding="{Binding Message}" ElementStyle="{StaticResource WrapText}" Width="*"/>
+                <DataGridTemplateColumn IsReadOnly="True" Header="Message" Width="*">
+                    <DataGridTemplateColumn.CellTemplate>
+                        <DataTemplate>
+                            <controls:LogMessageTemplate Message="{Binding Message}" Foreground="White"></controls:LogMessageTemplate>
+                        </DataTemplate>
+                    </DataGridTemplateColumn.CellTemplate>
+                </DataGridTemplateColumn>
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
@@ -1,10 +1,15 @@
-using Daybreak.Services.Logging;
+using Daybreak.Models;
+using Daybreak.Services.Logging;
 using Daybreak.Services.ViewManagement;
+using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
+using Microsoft.Win32;
 using System;
 using System.Collections.ObjectModel;
 using System.Extensions;
+using System.IO;
+using System.Linq;
 using System.Windows.Controls;
-using WpfExtended.Models;

 namespace Daybreak.Views
 {
@@ -15,22 +20,47 @@ namespace Daybreak.Views
    {
        private readonly IViewManager viewManager;
        private readonly ILogsManager logManager;
+        private readonly ILogger<LogsView> logger;

        public ObservableCollection<Log> Logs { get; } = new ObservableCollection<Log>();

        public LogsView(
            IViewManager viewManager,
-            ILogsManager logManager)
+            ILogsManager logManager,
+            ILogger<LogsView> logger)
        {
            this.logManager = logManager.ThrowIfNull(nameof(logManager));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
+            this.logger = logger.ThrowIfNull(nameof(logger));
            this.InitializeComponent();
            this.UpdateLogs();
        }

        private void UpdateLogs()
        {
-            this.Logs.ClearAnd().AddRange(this.logManager.GetLogs());
+            this.Logs.ClearAnd().AddRange(this.logManager.GetLogs(l => l.LogLevel < Microsoft.Extensions.Logging.LogLevel.Trace));
+        }
+        private async void ExportButton_Clicked(object sender, EventArgs e)
+        {
+            this.logger.LogInformation("Exporting logs");
+            var saveFileDialog = new SaveFileDialog
+            {
+                DefaultExt = "json",
+                Filter = "Json files (*.json)|*.json",
+                Title = "Export logs",
+                ValidateNames = true,
+                CreatePrompt = true
+            };
+            if (saveFileDialog.ShowDialog() is true)
+            {
+                var fileName = saveFileDialog.FileName;
+                this.logger.LogInformation($"Exporting to {fileName}");
+                await File.WriteAllTextAsync(fileName, this.logManager.GetLogs().ToList().Serialize());
+            }
+            else
+            {
+                this.logger.LogInformation("Exporting canceled");
+            }
        }
        private void BackButton_Clicked(object sender, EventArgs e)
        {
@@ -1,13 +1,14 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Exceptions;
 using Daybreak.Models.Builds;
 using Daybreak.Services.ApplicationLauncher;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.Screens;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Threading;
@@ -27,7 +28,7 @@ namespace Daybreak.Views
    {
        private readonly IApplicationLauncher applicationDetector;
        private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
        private readonly IScreenManager screenManager;
        private readonly IBuildTemplateManager buildTemplateManager;
        private readonly ILogger<ChromiumBrowserWrapper> browserLogger;
@@ -58,7 +59,7 @@ namespace Daybreak.Views
        public MainView(
            IApplicationLauncher applicationDetector,
            IViewManager viewManager,
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions,
            IScreenManager screenManager,
            IBuildTemplateManager buildTemplateManager,
            ILogger<ChromiumBrowserWrapper> browserLogger)
@@ -66,7 +67,7 @@ namespace Daybreak.Views
            this.browserLogger = browserLogger;
            this.buildTemplateManager = buildTemplateManager.ThrowIfNull(nameof(buildTemplateManager));
            this.screenManager = screenManager.ThrowIfNull(nameof(screenManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.applicationDetector = applicationDetector.ThrowIfNull(nameof(applicationDetector));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.InitializeComponent();
@@ -77,13 +78,13 @@ namespace Daybreak.Views

        private void InitializeBrowsers()
        {
-            this.LeftWebBrowser.InitializeBrowser(this.configurationManager, this.buildTemplateManager, this.browserLogger);
-            this.RightWebBrowser.InitializeBrowser(this.configurationManager, this.buildTemplateManager, this.browserLogger);
+            this.LeftWebBrowser.InitializeBrowser(this.liveOptions, this.buildTemplateManager, this.browserLogger);
+            this.RightWebBrowser.InitializeBrowser(this.liveOptions, this.buildTemplateManager, this.browserLogger);
        }

        private void NavigateToDefaults()
        {
-            var applicationConfiguration = this.configurationManager.GetConfiguration();
+            var applicationConfiguration = this.liveOptions.Value;
            if (applicationConfiguration.BrowsersEnabled)
            {
                this.LeftBrowserFavoriteAddress = applicationConfiguration.LeftBrowserDefault;
@@ -127,21 +128,22 @@ namespace Daybreak.Views
                    return;
                }

-                if (this.configurationManager.GetConfiguration().SetGuildwarsWindowSizeOnLaunch)
+                if (this.liveOptions.Value.SetGuildwarsWindowSizeOnLaunch)
                {
-                    var id = this.configurationManager.GetConfiguration().DesiredGuildwarsScreen;
+                    var id = this.liveOptions.Value.DesiredGuildwarsScreen;
                    var desiredScreen = this.screenManager.Screens.Skip(id).FirstOrDefault();
                    if (desiredScreen is null)
                    {
                        throw new InvalidOperationException($"Unable to set guildwars on desired screen. No screen with id {id}");
                    }
+
                    await Task.Delay(1000);
                    this.screenManager.MoveGuildwarsToScreen(desiredScreen);
                }

-                if (this.configurationManager.GetConfiguration().ToolboxAutoLaunch is true)
+                if (this.liveOptions.Value.ToolboxAutoLaunch is true)
                {
-                    var delay = this.configurationManager.GetConfiguration().ExperimentalFeatures.ToolboxAutoLaunchDelay;
+                    var delay = this.liveOptions.Value.ExperimentalFeatures.ToolboxAutoLaunchDelay;
                    await Task.Delay(delay);
                    await this.applicationDetector.LaunchGuildwarsToolbox();
                }
@@ -180,23 +182,23 @@ namespace Daybreak.Views
            }
        }

-        private void ChromiumBrowserWrapper_BuildDecoded(object sender, Models.Builds.Build e)
+        private void ChromiumBrowserWrapper_BuildDecoded(object sender, Build e)
        {
            this.viewManager.ShowView<BuildTemplateView>(new BuildEntry { Build = e, Name = string.Empty });
        }

        private void LeftBrowser_FavoriteUriChanged(object sender, string e)
        {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveOptions.Value;
            config.LeftBrowserDefault = e;
-            this.configurationManager.SaveConfiguration(config);
+            this.liveOptions.UpdateOption();
        }

        private void RightBrowser_FavoriteUriChanged(object sender, string e)
        {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveOptions.Value;
            config.RightBrowserDefault = e;
-            this.configurationManager.SaveConfiguration(config);
+            this.liveOptions.UpdateOption();
        }

        private void LeftChromiumBrowserWrapper_MaximizeClicked(object sender, EventArgs e)
@@ -1,13 +1,13 @@
-using Daybreak.Controls.Templates;
+using Daybreak.Configuration;
+using Daybreak.Controls.Templates;
 using Daybreak.Models;
 using Daybreak.Services.ApplicationLauncher;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.Screens;
 using Daybreak.Services.ViewManagement;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
-using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
 using System.Windows.Media;
@@ -23,7 +23,7 @@ namespace Daybreak.Views
    {        
        private readonly IScreenManager screenManager;
        private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
        private readonly IApplicationLauncher applicationLauncher;
        private int selectedId;

@@ -33,15 +33,15 @@ namespace Daybreak.Views
        public ScreenChoiceView(
            IViewManager viewManager,
            IScreenManager screenManager,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
            IApplicationLauncher applicationLauncher)
        {
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.screenManager = screenManager.ThrowIfNull(nameof(screenManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
            this.applicationLauncher = applicationLauncher.ThrowIfNull(nameof(applicationLauncher));
            this.InitializeComponent();
-            this.selectedId = configurationManager.GetConfiguration().DesiredGuildwarsScreen;
+            this.selectedId = this.liveOptions.Value.DesiredGuildwarsScreen;
            this.CanTest = applicationLauncher.IsGuildwarsRunning;
            this.SetupView();
        }
@@ -59,8 +59,8 @@ namespace Daybreak.Views
                    VerticalAlignment = System.Windows.VerticalAlignment.Top,
                    HorizontalAlignment = System.Windows.HorizontalAlignment.Left,
                    Foreground = screen.Id == this.selectedId ? Brushes.LightGreen : Brushes.White
-            };
-                screenTemplate.Clicked += ScreenTemplate_Clicked;
+                };
+                screenTemplate.Clicked += this.ScreenTemplate_Clicked;
                this.ScreenContainer.Children.Add(screenTemplate);
            }
        }
@@ -86,7 +86,7 @@ namespace Daybreak.Views

        private void SaveButton_Clicked(object sender, EventArgs e)
        {
-            this.configurationManager.GetConfiguration().DesiredGuildwarsScreen = this.selectedId;
+            this.liveOptions.Value.DesiredGuildwarsScreen = this.selectedId;
            this.viewManager.ShowView<SettingsCategoryView>();
        }

@@ -1,11 +1,8 @@
-using Daybreak.Services.Configuration;
-using Daybreak.Services.Shortcuts;
+using Daybreak.Configuration;
 using Daybreak.Services.ViewManagement;
-using Microsoft.Win32;
 using System;
+using System.Configuration;
 using System.Extensions;
-using System.Windows;
-using System.Windows.Controls;
 using System.Windows.Extensions;
 using System.Windows.Forms;

@@ -18,7 +15,7 @@ namespace Daybreak.Views
    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
    public partial class SettingsView : System.Windows.Controls.UserControl
    {
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;
        private readonly IViewManager viewManager;

        [GenerateDependencyProperty]
@@ -49,10 +46,10 @@ namespace Daybreak.Views
        private bool keepLocalIconCache;

        public SettingsView(
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions,
            IViewManager viewManager)
        {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
            this.InitializeComponent();
            this.LoadSettings();
@@ -60,7 +57,7 @@ namespace Daybreak.Views

        private void LoadSettings()
        {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
            this.AddressBarReadonly = config.AddressBarReadonly;
            this.ToolboxPath = config.ToolboxPath;
            this.LeftBrowserUrl = config.LeftBrowserDefault;
@@ -78,7 +75,7 @@ namespace Daybreak.Views

        private void SaveButton_Clicked(object sender, EventArgs e)
        {
-            var currentConfig = this.configurationManager.GetConfiguration();
+            var currentConfig = this.liveUpdateableOptions.Value;
            currentConfig.ToolboxPath = this.ToolboxPath;
            currentConfig.AddressBarReadonly = this.AddressBarReadonly;
            currentConfig.LeftBrowserDefault = this.LeftBrowserUrl;
@@ -92,7 +89,7 @@ namespace Daybreak.Views
            currentConfig.PlaceShortcut = this.ShortcutPlaced;
            currentConfig.AutoCheckUpdate = this.AutoCheckUpdate;
            currentConfig.KeepLocalIconCache = this.KeepLocalIconCache;
-            this.configurationManager.SaveConfiguration(currentConfig);
+            this.liveUpdateableOptions.UpdateOption();
            this.viewManager.ShowView<SettingsCategoryView>();
        }
Author	SHA1	Message	Date
amacocianandGitHub	3798daa54e	Update dependencies (#21 ) * Update dependencies * Minor nit fixes * Fix UTs	2021-07-10 12:08:43 +03:00
amacocianandGitHub	624380ed86	Use IOptions instead of IConfigurationManager (#20 ) * Use IOptions instead of dependency on IConfigurationManager	2021-06-22 15:48:37 +03:00
amacocianandGitHub	2b025e225b	Updated wpfextended dependency	2021-06-11 13:50:58 +02:00
amacocianandGitHub	15a67ea28c	Minor fixes Stop showing browser when browser is disabled Prevent setting address of browser when browser is disabled (should prevent browser from instantiating when disabled) Ignore errors from browser caused by switching view before the browser could be initialized Provide expression to filter logs Button to export logs to json file	2021-06-07 14:33:54 +02:00
amacocianandGitHub	c6b62fd5fd	Logging improvements Log uncaught exceptions Logview expander	2021-06-07 00:34:43 +02:00