Implement search bar for builds and skills (#50)

* Add search bars to builds and skills

* Fix search bar not appearing.
Improve search function.

* Increment version

* Rename version check so it can be added to status checks

.github/workflows/cd.yaml

@@ -0,0 +1,101 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+# This continuous integration pipeline is triggered anytime a user pushes code to the repo.
+# This pipeline builds the Wpf project, runs unit tests, then saves the MSIX build artifact.
+name:  Daybreak CD Pipeline
+
+on:
+  push:
+    branches:
+      - master
+      
+jobs:
+
+  build:
+
+    strategy:
+      matrix:
+        targetplatform: [x64]
+
+    runs-on: windows-latest
+
+    env:
+      Configuration: Release
+      Solution_Path: Daybreak.sln
+      Test_Project_Path: Daybreak.Tests\Daybreak.Tests.csproj
+      Wpf_Project_Path: Daybreak\Daybreal.csproj
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Get Latest Tag
+      id: getLatestTag
+      uses: WyriHaximus/github-action-get-previous-tag@v1
+
+    - name: Generate changelog
+      id: gen_changelog
+      run: |
+        $changeLog = git log --no-merges --pretty="%h - %s (%an)<br />" ${{ env.LatestReleaseTag }}..HEAD
+        echo "::set-env name=Changelog::$changeLog"
+      env:
+        LatestReleaseTag: ${{steps.getLatestTag.outputs.tag}}
+
+    - name: Print changelog
+      run: |
+        echo "${{ env.Changelog }}"
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '6.x'
+
+    - name: Setup MSBuild.exe
+      uses: microsoft/setup-msbuild@v1.0.1
+
+    - name:  Restore project
+      run: msbuild $env:Solution_Path /t:Restore /p:Configuration=$env:Configuration /p:RuntimeIdentifier=$env:RuntimeIdentifier
+      env:
+        RuntimeIdentifier: win-${{ matrix.targetplatform }}
+
+    - name: Build Daybreak project
+      run: dotnet build Daybreak -c $env:Configuration
+
+    - name: Set version variable
+      run: |
+        $version = .\Scripts\GetBuildVersion.ps1
+        echo "::set-env name=Version::$version"
+
+    - name: Create publish launcher files
+      run: dotnet publish .\Daybreak\Daybreak.csproj -c $env:Configuration -r $env:RuntimeIdentifier -p:PublishReadyToRun=true -p:PublishSingleFile=true --self-contained true -o .\Publish
+      env:
+        RuntimeIdentifier: win-${{ matrix.targetplatform }}
+
+    - name: Create publish installer files
+      run: dotnet publish .\Daybreak.Installer\Daybreak.Installer.csproj -c $env:Configuration -r $env:RuntimeIdentifier -p:PublishReadyToRun=true -p:PublishSingleFile=true --self-contained true -o .\Publish
+      env:
+        RuntimeIdentifier: win-${{ matrix.targetplatform }}
+
+    - name: Pack publish files
+      run: |
+        Write-Host $env
+        .\Scripts\BuildRelease.ps1 -version $env:Version
+      shell: pwsh
+
+    - name: Publish release
+      uses: Xotl/cool-github-releases@v1.1.2
+      with:
+        mode: update
+        tag_name: v${{ env.Version }}
+        release_name: Daybreak v${{ env.Version }}
+        assets: .\Publish\daybreakv${{ env.Version }}.zip
+        github_token: ${{ env.GITHUB_TOKEN }}
+        replace_assets: true
+        body_mrkdwn: ${{ env.Changelog }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    

.github/workflows/ci.yaml

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+# This continuous integration pipeline is triggered anytime a user pushes code to the repo.
+# This pipeline builds the Wpf project, runs unit tests, then saves the MSIX build artifact.
+name:  Daybreak CI Pipeline
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+
+  build:
+
+    strategy:
+      matrix:
+        targetplatform: [x64]
+
+    runs-on: windows-latest
+
+    env:
+      Solution_Path: Daybreak.sln
+      Test_Project_Path: Daybreak.Tests\Daybreak.Tests.csproj
+      Wpf_Project_Path: Daybreak\Daybreal.csproj
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '6.x'
+
+    - name: Setup MSBuild.exe
+      uses: microsoft/setup-msbuild@v1.0.1
+
+    - name: Execute Unit Tests
+      run: dotnet test $env:Test_Project_Path
+
+    - name:  Restore the Wpf application to populate the obj folder
+      run: msbuild $env:Solution_Path /t:Restore /p:Configuration=$env:Configuration /p:RuntimeIdentifier=$env:RuntimeIdentifier
+      env:
+        Configuration: Debug
+        RuntimeIdentifier: win-${{ matrix.targetplatform }}

.github/workflows/version_check.yaml

@@ -0,0 +1,45 @@
+name:  Daybreak Version Check
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+
+  check_version:
+
+    strategy:
+      matrix:
+        targetplatform: [x64]
+
+    runs-on: windows-latest
+
+    env:
+      Configuration: Release
+      Solution_Path: Daybreak.sln
+      Actions_Allow_Unsecure_Commands: true
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    
+    - name: Get Latest Tag
+      id: getLatestTag
+      uses: WyriHaximus/github-action-get-previous-tag@v1
+
+    - name: Build Daybreak project
+      run: dotnet build Daybreak -c $env:Configuration
+
+    - name: Set version variable
+      run: |
+        $version = .\Scripts\GetBuildVersion.ps1
+        echo "::set-env name=Version::$version"
+
+    - name: Check version difference
+      run: |
+        .\Scripts\CompareVersions -currentVersion ${{ env.Version }} -lastVersion ${{ env.LatestReleaseTag }}
+      env:
+        LatestReleaseTag: ${{ steps.getLatestTag.outputs.tag }}

.gitignore

@@ -9,6 +9,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+*.version
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs

Daybreak.Installer/Daybreak.Installer.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

Daybreak.Installer/Program.cs

@@ -0,0 +1,41 @@
+// See https://aka.ms/new-console-template for more information
+using System.Diagnostics;
+using System.IO.Compression;
+
+const string tempFile = "tempfile.zip";
+const string executableName = "Daybreak.exe";
+Console.Title = "Daybreak Installer";
+Console.WriteLine("Starting installation...");
+if (File.Exists(tempFile) is false)
+{
+    Console.ForegroundColor = ConsoleColor.Red;
+    Console.WriteLine("Unable to find launcher package. Aborting installation");
+    Console.ReadKey();
+    return;
+}
+
+Console.WriteLine("Unpacking files...");
+try
+{
+    ZipFile.ExtractToDirectory(tempFile, AppContext.BaseDirectory, true);
+}
+catch
+{
+
+}
+Console.WriteLine("Deleting package");
+File.Delete(tempFile);
+Console.WriteLine("Launching application");
+var process = new Process
+{
+    StartInfo = new ProcessStartInfo
+    {
+        FileName = executableName
+    }
+};
+
+if (process.Start() is false)
+{
+    Console.WriteLine("Failed to launch application");
+    Console.ReadKey();
+}

Daybreak.Tests/Daybreak.Tests.csproj

@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0-windows</TargetFramework>
-
+    <TargetFramework>net6.0-windows</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="6.0.0-alpha0002" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
-    <PackageReference Include="Moq" Version="4.16.1" />
-    <PackageReference Include="MSTest.TestAdapter" Version="2.1.1" />
-    <PackageReference Include="MSTest.TestFramework" Version="2.1.1" />
-    <PackageReference Include="coverlet.collector" Version="1.3.0" />
+    <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0-preview-20220707-01" />
+    <PackageReference Include="Moq" Version="4.18.2" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" />
+    <PackageReference Include="System.Linq.Async" Version="6.0.1" />
   </ItemGroup>
 
   <ItemGroup>

Daybreak.Tests/Models/VersionTests.cs

@@ -0,0 +1,136 @@
+using Daybreak.Models.Versioning;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Linq;
+using Version = Daybreak.Models.Versioning.Version;
+
+namespace Daybreak.Tests.Models
+{
+    [TestClass]
+    public class VersionTests
+    {
+        [DataRow("v0.1.0.0.1", "v0.1.0.0.1")]
+        [DataRow("v0.1.0.0.1.0.0.0.0", "v0.1.0.0.1")]
+        [DataRow("v0.1.0", "v0.1")]
+        [DataRow("0.1.0", "0.1")]
+        [DataRow("v0.1.0.0.0", "v0.1")]
+        [DataRow("0.1.0.0.0", "0.1")]
+        [DataRow("v0", "v0")]
+        [DataRow("0", "0")]
+        [DataRow("v0.1", "v0.1")]
+        [DataRow("0.1-release", "0.1-release")]
+        [DataRow("v0.1-release", "v0.1-release")]
+        [TestMethod]
+        public void VersionToString(string version, string expectedString)
+        {
+            var parsedVersion = Version.Parse(version);
+            parsedVersion.ToString().Should().Be(expectedString);
+        }
+
+        [DataRow("v0", false)]
+        [DataRow("0", false)]
+        [DataRow("v0.1", false)]
+        [DataRow("0.1-release", true)]
+        [DataRow("v0.1-release", true)]
+        [TestMethod]
+        public void VersionHasStringSuffix(string version, bool hasSuffix)
+        {
+            var parsedVersion = Version.Parse(version);
+            if (hasSuffix)
+            {
+                parsedVersion.VersionTokens.Last().Should().BeOfType<VersionStringToken>();
+            }
+            else
+            {
+                parsedVersion.VersionTokens.Last().Should().BeOfType<VersionNumberToken>();
+            }
+        }
+
+        [DataRow("v0", true)]
+        [DataRow("0", false)]
+        [DataRow("v0.1", true)]
+        [DataRow("0.1", false)]
+        [TestMethod]
+        public void VersionTokensHasPrefix(string version, bool hasPrefix)
+        {
+            var parsedVersion = Version.Parse(version);
+            parsedVersion.HasPrefix.Should().Be(hasPrefix);
+        }
+
+        [DataRow(null, false)]
+        [DataRow("", false)]
+        [DataRow("asd", false)]
+        [DataRow("ads.pls.er", false)]
+        [DataRow("0.0.1", true)]
+        [DataRow("1", true)]
+        [DataRow("0.1.asd", false)]
+        [DataRow("0.", false)]
+        [DataRow(".1", false)]
+        [DataRow("0.1-", false)]
+        [DataRow("0.1-release", true)]
+        [DataRow("0..1", false)]
+        [TestMethod]
+        public void TryParseVersionTest(string version, bool result)
+        {
+            var success = Version.TryParse(version, out var parsedVersion);
+            success.Should().Be(result);
+            if (success is true)
+            {
+                parsedVersion.Should().NotBeNull();
+            }
+        }
+
+        [DataRow(null, false)]
+        [DataRow("", false)]
+        [DataRow("asd", false)]
+        [DataRow("ads.pls.er", false)]
+        [DataRow("0.0.1", true)]
+        [DataRow("1", true)]
+        [DataRow("0.1.asd", false)]
+        [DataRow("0.", false)]
+        [DataRow(".1", false)]
+        [DataRow("0.1-", false)]
+        [DataRow("0.1-release", true)]
+        [DataRow("0..1", false)]
+        [TestMethod]
+        public void ParseVersionTest(string version, bool shouldNotThrow)
+        {
+            var action = new Action(() => Version.Parse(version));
+            if (shouldNotThrow is false)
+            {
+                action.Should().Throw<InvalidOperationException>();
+            }
+            else
+            {
+                action.Should().NotThrow<InvalidOperationException>();
+            }
+        }
+
+        [DataRow(null, false)]
+        [DataRow("", false)]
+        [DataRow("asd", false)]
+        [DataRow("ads.pls.er", false)]
+        [DataRow("0.0.1", true)]
+        [DataRow("1", true)]
+        [DataRow("0.1.asd", false)]
+        [DataRow("0.", false)]
+        [DataRow(".1", false)]
+        [DataRow("0.1-", false)]
+        [DataRow("0.1-release", true)]
+        [DataRow("0..1", false)]
+        [TestMethod]
+        public void VersionConstructorTest(string version, bool shouldNotThrow)
+        {
+            var action = new Action(() => new Version(version));
+            if (shouldNotThrow is false)
+            {
+                action.Should().Throw<ArgumentException>();
+            }
+            else
+            {
+                action.Should().NotThrow<ArgumentException>();
+            }
+        }
+    }
+}

Daybreak.Tests/Services/ApplicationConfigurationOptionsManagerTests.cs

@@ -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>();
+        }
+    }
+}

Daybreak.Tests/Services/BuildTemplateManagerTests.cs

@@ -1,7 +1,7 @@
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Logging;
 using FluentAssertions;
+using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 using System.Collections.Generic;
@@ -17,7 +17,7 @@ namespace Daybreak.Tests.Services
         [TestInitialize]
         public void Initialize()
         {
-            buildTemplateManager = new BuildTemplateManager(new Mock<ILogger>().Object);
+            buildTemplateManager = new BuildTemplateManager(new Mock<ILogger<BuildTemplateManager>>().Object);
         }
 
         [TestMethod]

Daybreak.Tests/Services/JsonLoggerProviderTests.cs

@@ -0,0 +1,74 @@
+using Daybreak.Services.Logging;
+using FluentAssertions;
+using LiteDB;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.IO;
+using System.Linq;
+using System.Logging;
+
+namespace Daybreak.Tests.Services
+{
+    [TestClass]
+    public class JsonLoggerProviderTests
+    {
+        private ILogsManager logsManager;
+        private ILoggerProvider loggerProvider;
+        private ILiteDatabase liteDatabase;
+
+        [TestInitialize]
+        public void InitializeProvider()
+        {
+            File.Delete("Daybreak.db");
+            this.liteDatabase = new LiteDatabase("Daybreak.db");
+            this.logsManager = new JsonLogsManager(this.liteDatabase);
+            this.loggerProvider = new CVLoggerProvider(this.logsManager);
+        }
+
+        [TestCleanup]
+        public void TestCleanup()
+        {
+            this.liteDatabase.Dispose();
+        }
+
+        [TestMethod]
+        public void CreateLoggerReturnsLogger()
+        {
+            var logger = this.loggerProvider.CreateLogger("SomeCategory");
+            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");
+            logger.LogInformation("Logging some stuff");
+            logger.LogError("Logging some error");
+
+            this.logsManager.GetLogs().Should().HaveCount(2);
+        }
+        [TestMethod]
+        public void DeletingLogsShouldDeleteLogs()
+        {
+            var logger = this.loggerProvider.CreateLogger("SomeCategory");
+            logger.LogInformation("Logging some stuff");
+            logger.LogError("Logging some error");
+
+            this.logsManager.GetLogs().Should().HaveCount(2);
+
+            this.logsManager.DeleteLogs();
+            this.logsManager.GetLogs().Should().HaveCount(0);
+        }
+    }
+}

Daybreak.sln

@@ -1,11 +1,27 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.31005.135
+# Visual Studio Version 17
+VisualStudioVersion = 17.2.32616.157
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Daybreak", "Daybreak\Daybreak.csproj", "{AA45C2B1-8BD0-466C-9271-699F168905AF}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Daybreak.Tests", "Daybreak.Tests\Daybreak.Tests.csproj", "{C911C1C2-6566-419C-89C7-F802EB3FE709}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Daybreak.Tests", "Daybreak.Tests\Daybreak.Tests.csproj", "{C911C1C2-6566-419C-89C7-F802EB3FE709}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Pipelines", "Pipelines", "{067BF93F-E5B2-4E99-886E-039C04F35EAB}"
+	ProjectSection(SolutionItems) = preProject
+		.github\workflows\cd.yaml = .github\workflows\cd.yaml
+		.github\workflows\ci.yaml = .github\workflows\ci.yaml
+		.github\workflows\version_check.yaml = .github\workflows\version_check.yaml
+	EndProjectSection
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Daybreak.Installer", "Daybreak.Installer\Daybreak.Installer.csproj", "{4E2BB805-135D-4F02-8C53-3D8B6876D323}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Scripts", "Scripts", "{41AE8C5D-25E1-4B08-8D65-868552421A63}"
+	ProjectSection(SolutionItems) = preProject
+		Scripts\BuildRelease.ps1 = Scripts\BuildRelease.ps1
+		Scripts\GetBuildVersion.ps1 = Scripts\GetBuildVersion.ps1
+		Scripts\CompareVersions.ps1 = Scripts\CompareVersions.ps1
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -17,12 +33,12 @@ Global
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|x64.ActiveCfg = Debug|x64
-		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|x64.Build.0 = Debug|x64
+		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Debug|x64.Build.0 = Debug|Any CPU
 		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|Any CPU.Build.0 = Release|Any CPU
-		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|x64.ActiveCfg = Release|x64
-		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|x64.Build.0 = Release|x64
+		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|x64.ActiveCfg = Release|Any CPU
+		{AA45C2B1-8BD0-466C-9271-699F168905AF}.Release|x64.Build.0 = Release|Any CPU
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Debug|x64.ActiveCfg = Debug|Any CPU
@@ -31,6 +47,14 @@ Global
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Release|x64.ActiveCfg = Release|Any CPU
 		{C911C1C2-6566-419C-89C7-F802EB3FE709}.Release|x64.Build.0 = Release|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Debug|x64.Build.0 = Debug|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Release|x64.ActiveCfg = Release|Any CPU
+		{4E2BB805-135D-4F02-8C53-3D8B6876D323}.Release|x64.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Daybreak/Behaviors/ScaleFontWithSize.cs

@@ -1,9 +1,9 @@
-using System;
+using Microsoft.Xaml.Behaviors;
+using System;
 using System.ComponentModel;
 using System.Globalization;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Interactivity;
 using System.Windows.Media;
 
 namespace Daybreak.Behaviors

Daybreak/Behaviors/ScrollIntoView.cs

@@ -1,7 +1,7 @@
-using System;
+using Microsoft.Xaml.Behaviors;
+using System;
 using System.Extensions;
 using System.Windows.Controls;
-using System.Windows.Interactivity;
 
 namespace Daybreak.Behaviors
 {

Daybreak/Configuration/ApplicationConfiguration.cs

@@ -1,5 +1,6 @@
 using Daybreak.Models;
 using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
 
 namespace Daybreak.Configuration
@@ -30,5 +31,11 @@ namespace Daybreak.Configuration
         public bool AddressBarReadonly { get; set; } = true;
         [JsonProperty("ExperimentalFeatures")]
         public ExperimentalFeatures ExperimentalFeatures { get; set; } = new();
+        [JsonProperty("ShortcutLocation")]
+        public string ShortcutLocation { get; set; } = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
+        [JsonProperty("PlaceShortcut")]
+        public bool PlaceShortcut { get; set; }
+        [JsonProperty("AutoCheckUpdate")]
+        public bool AutoCheckUpdate { get; set; } = true;
     }
 }

Daybreak/Configuration/ExperimentalFeatures.cs

@@ -1,4 +1,6 @@
-using Newtonsoft.Json;
+using Daybreak.Models;
+using Newtonsoft.Json;
+using System.Collections.Generic;
 
 namespace Daybreak.Configuration
 {
@@ -12,5 +14,11 @@ namespace Daybreak.Configuration
         public bool DynamicBuildLoading { get; set; } = true;
         [JsonProperty("LaunchGuildwarsAsCurrentUser")]
         public bool LaunchGuildwarsAsCurrentUser { get; set; } = true;
+        [JsonProperty("CanInterceptKeys")]
+        public bool CanInterceptKeys { get; set; }
+        [JsonProperty("DownloadIcons")]
+        public bool DownloadIcons { get; set; }
+        [JsonProperty("Macros")]
+        public List<KeyMacro> Macros { get; set; } = new();
     }
 }

Daybreak/Configuration/ProjectConfiguration.cs

@@ -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,48 +7,76 @@ 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;
 using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
+using Microsoft.Extensions.Http.Logging;
+using Microsoft.Extensions.Logging;
 using Slim;
 using System.Extensions;
+using System.Net.Http;
+using LiteDB;
+using Daybreak.Services.Options;
+using Daybreak.Models;
+using Microsoft.CorrelationVector;
+using System.Logging;
 
 namespace Daybreak.Configuration
 {
     public static class ProjectConfiguration
     {
+        public static void RegisterResolvers(IServiceManager serviceManager)
+        {
+            serviceManager.ThrowIfNull(nameof(serviceManager));
+
+            serviceManager.RegisterHttpFactory((serviceProvider, categoryType) =>
+            {
+                var loggerType = typeof(ILogger<>).MakeGenericType(categoryType);
+                var logger = serviceProvider.GetService(loggerType).As<ILogger>();
+                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<ICredentialManager, CredentialManager>();
-            serviceProducer.RegisterSingleton<ILoggingDatabase, FlatLoggingDatabase>();
-            serviceProducer.RegisterSingleton<ILogger, Logger>();
-            serviceProducer.RegisterSingleton<ApplicationLifetimeManager>();
-            serviceProducer.RegisterSingleton<ViewManager>();
-            serviceProducer.RegisterSingleton<IApplicationLauncher, ApplicationLauncher>();
-            serviceProducer.RegisterSingleton<IScreenshotProvider, ScreenshotProvider>();
-            serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
-            serviceProducer.RegisterSingleton<IBloogumClient, BloogumClient>();
-            serviceProducer.RegisterSingleton<IApplicationUpdater, ApplicationUpdater>();
-            serviceProducer.RegisterSingleton<IMutexHandler, MutexHandler>();
-            serviceProducer.RegisterSingleton<IRuntimeStore, RuntimeStore>();
-            serviceProducer.RegisterSingleton<IBuildTemplateManager, BuildTemplateManager>();
-            serviceProducer.RegisterSingleton<IIconRetriever, IconRetriever>();
-            serviceProducer.RegisterSingleton<IPrivilegeManager, PrivilegeManager>();
-            serviceProducer.RegisterSingleton<IScreenManager, ScreenManager>();
-        }
-        public static void RegisterLifetimeServices(IApplicationLifetimeProducer applicationLifetimeProducer)
-        {
-            applicationLifetimeProducer.ThrowIfNull(nameof(applicationLifetimeProducer));
+            serviceProducer.RegisterSingleton<ILogsManager, JsonLogsManager>();
+            serviceProducer.RegisterSingleton<IDebugLogsWriter, Services.Logging.DebugLogsWriter>();
+            serviceProducer.RegisterSingleton<ILoggerFactory, LoggerFactory>(sp =>
+            {
+                var factory = new LoggerFactory();
+                factory.AddProvider(new CVLoggerProvider(sp.GetService<ILogsWriter>()));
+                return factory;
+            });
+            serviceProducer.RegisterSingleton<ILogsWriter, CompositeLogsWriter>(sp => new CompositeLogsWriter(
+                sp.GetService<ILogsManager>(),
+                sp.GetService<IDebugLogsWriter>()));
 
-            applicationLifetimeProducer.RegisterService<ILoggingDatabase>();
-            applicationLifetimeProducer.RegisterService<IScreenshotProvider>();
-            applicationLifetimeProducer.RegisterService<IApplicationUpdater>();
+            serviceProducer.RegisterScoped((sp) => new ScopeMetadata(new CorrelationVector()));
+            serviceProducer.RegisterSingleton<ViewManager>(registerAllInterfaces: true);
+            serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
+            serviceProducer.RegisterSingleton<ILiteDatabase, LiteDatabase>(sp => new LiteDatabase("Daybreak.db"));
+            serviceProducer.RegisterSingleton<IMutexHandler, MutexHandler>();
+            serviceProducer.RegisterSingleton<IShortcutManager, ShortcutManager>();
+            serviceProducer.RegisterSingleton<IIconBrowser, IconBrowser>();
+            serviceProducer.RegisterSingleton<IIconDownloader, IconDownloader>();
+            serviceProducer.RegisterScoped<ICredentialManager, CredentialManager>();
+            serviceProducer.RegisterScoped<IApplicationLauncher, ApplicationLauncher>();
+            serviceProducer.RegisterScoped<IScreenshotProvider, ScreenshotProvider>();
+            serviceProducer.RegisterScoped<IBloogumClient, BloogumClient>();
+            serviceProducer.RegisterScoped<IApplicationUpdater, ApplicationUpdater>();
+            serviceProducer.RegisterScoped<IBuildTemplateManager, BuildTemplateManager>();
+            serviceProducer.RegisterScoped<IIconCache, IconCache>();
+            serviceProducer.RegisterScoped<IPrivilegeManager, PrivilegeManager>();
+            serviceProducer.RegisterScoped<IScreenManager, ScreenManager>();
         }
+
         public static void RegisterViews(IViewProducer viewProducer)
         {
             viewProducer.ThrowIfNull(nameof(viewProducer));
@@ -66,6 +93,9 @@ namespace Daybreak.Configuration
             viewProducer.RegisterView<BuildsListView>();
             viewProducer.RegisterView<RequestElevationView>();
             viewProducer.RegisterView<ScreenChoiceView>();
+            viewProducer.RegisterView<VersionManagementView>();
+            viewProducer.RegisterView<LogsView>();
+            viewProducer.RegisterView<IconDownloadView>();
         }
     }
 }

Daybreak/Controls/Buttons/TileButton.xaml

@@ -4,7 +4,7 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
              xmlns:local="clr-namespace:Daybreak.Controls"
-             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
+             xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
              xmlns:behaviors="clr-namespace:Daybreak.Behaviors"
              xmlns:converters="clr-namespace:Daybreak.Converters"
              x:Name="_this"

Daybreak/Controls/ChromiumBrowserWrapper.xaml.cs

@@ -1,12 +1,12 @@
-using Daybreak.Launch;
+using Daybreak.Configuration;
 using Daybreak.Models.Browser;
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
-using Daybreak.Services.Logging;
 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;
@@ -19,83 +19,57 @@ namespace Daybreak.Controls
     /// <summary>
     /// Interaction logic for ChromiumBrowserWrapper.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [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 readonly static DependencyProperty AddressProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, string>(nameof(Address));
-        public readonly static DependencyProperty FavoriteAddressProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, string>(nameof(FavoriteAddress));
-        public readonly static DependencyProperty NavigatingProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(Navigating));
-        public readonly static DependencyProperty BrowserEnabledProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(BrowserEnabled));
-        public readonly static DependencyProperty AddressBarReadonlyProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(AddressBarReadonly));
-        public readonly static DependencyProperty BrowserSupportedProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(BrowserSupported), new PropertyMetadata(true));
-        public readonly static DependencyProperty ControlsEnabledProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(ControlsEnabled), new PropertyMetadata(true));
-        public readonly static DependencyProperty CanNavigateProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(CanNavigate), new PropertyMetadata(true));
-        public readonly static DependencyProperty CanDownloadBuildProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(CanDownloadBuild), new PropertyMetadata(false));
+        private static CoreWebView2Environment coreWebView2Environment;
 
         public event EventHandler<string> FavoriteUriChanged;
         public event EventHandler MaximizeClicked;
         public event EventHandler<Build> BuildDecoded;
 
-        private readonly IConfigurationManager configurationManager;
-        private readonly ILogger logger;
-        private readonly IBuildTemplateManager buildTemplateManager;
-        private CoreWebView2Environment coreWebView2Environment;
-
-        public bool CanDownloadBuild
-        {
-            get => this.GetTypedValue<bool>(CanDownloadBuildProperty);
-            set => this.SetTypedValue<bool>(CanDownloadBuildProperty, value);
-        }
-        public bool CanNavigate
-        {
-            get => this.GetTypedValue<bool>(CanNavigateProperty);
-            set => this.SetTypedValue<bool>(CanNavigateProperty, value);
-        }
+        private ILiveOptions<ApplicationConfiguration> liveOptions;
+        private ILogger<ChromiumBrowserWrapper> logger;
+        private IBuildTemplateManager buildTemplateManager;
+        
+        [GenerateDependencyProperty(InitialValue = true)]
+        private bool canDownloadBuild;
+        [GenerateDependencyProperty(InitialValue = true)]
+        private bool canNavigate;
+        [GenerateDependencyProperty(InitialValue = true)]
+        private bool controlsEnabled;
+        [GenerateDependencyProperty(InitialValue = null)]
+        private bool? browserSupported;
+        [GenerateDependencyProperty]
+        private bool addressBarReadonly;
+        [GenerateDependencyProperty]
+        private bool browserEnabled;
+        [GenerateDependencyProperty]
+        private bool navigating;
+        [GenerateDependencyProperty]
+        private string favoriteAddress;
         public string Address
         {
             get => this.GetTypedValue<string>(AddressProperty);
-            set => this.SetTypedValue(AddressProperty, value);
-        }
-        public string FavoriteAddress
-        {
-            get => this.GetTypedValue<string>(FavoriteAddressProperty);
-            set => this.SetTypedValue(FavoriteAddressProperty, value);
-        }
-        public bool Navigating
-        {
-            get => this.GetTypedValue<bool>(NavigatingProperty);
-            private set => this.SetTypedValue<bool>(NavigatingProperty, value);
-        }
-        public bool AddressBarReadonly
-        {
-            get => this.GetTypedValue<bool>(AddressBarReadonlyProperty);
-            set => this.SetTypedValue<bool>(AddressBarReadonlyProperty, value);
-        }
-        public bool BrowserEnabled
-        {
-            get => this.GetTypedValue<bool>(BrowserEnabledProperty);
-            private set => this.SetTypedValue<bool>(BrowserEnabledProperty, value);
-        }
-        public bool BrowserSupported
-        {
-            get => this.GetTypedValue<bool>(BrowserSupportedProperty);
-            private set => this.SetTypedValue<bool>(BrowserSupportedProperty, value);
-        }
-        public bool ControlsEnabled
-        {
-            get => this.GetTypedValue<bool>(ControlsEnabledProperty);
-            set => this.SetTypedValue<bool>(ControlsEnabledProperty, value);
+            set
+            {
+                if (this.BrowserSupported is true)
+                {
+                    this.SetValue(AddressProperty, value);
+                }
+            }
         }
 
         public ChromiumBrowserWrapper()
         {
-            this.configurationManager = Launcher.ApplicationServiceManager.GetService<IConfigurationManager>();
-            this.logger = Launcher.ApplicationServiceManager.GetService<ILogger>();
-            this.buildTemplateManager = Launcher.ApplicationServiceManager.GetService<IBuildTemplateManager>();
             this.InitializeComponent();
-            this.InitializeEnvironment();
-            this.InitializeBrowser();
+            this.WebBrowser.IsEnabled = false;
         }
 
         protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
@@ -107,6 +81,18 @@ namespace Daybreak.Controls
             }
         }
 
+        public async Task InitializeBrowser(
+            ILiveOptions<ApplicationConfiguration> liveOptions,
+            IBuildTemplateManager buildTemplateManager,
+            ILogger<ChromiumBrowserWrapper> logger)
+        {
+            this.liveOptions = liveOptions;
+            this.buildTemplateManager = buildTemplateManager;
+            this.logger = logger;
+            this.InitializeEnvironment();
+            await this.InitializeBrowser();
+        }
+
         public async void ReinitializeBrowser()
         {
             await this.InitializeBrowser();
@@ -114,7 +100,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;
@@ -122,7 +108,11 @@ namespace Daybreak.Controls
 
             try
             {
-                this.coreWebView2Environment = System.Extensions.TaskExtensions.RunSync(() => CoreWebView2Environment.CreateAsync(null, "BrowserData", null));
+                if (coreWebView2Environment is null)
+                {
+                    coreWebView2Environment = System.Extensions.TaskExtensions.RunSync(() => CoreWebView2Environment.CreateAsync(null, "BrowserData", null));
+                }
+
                 this.BrowserSupported = true;
             }
             catch(Exception e)
@@ -136,9 +126,11 @@ namespace Daybreak.Controls
         {
             if (this.BrowserSupported is true)
             {
-                await this.WebBrowser.EnsureCoreWebView2Async(this.coreWebView2Environment);
-                this.AddressBarReadonly = this.configurationManager.GetConfiguration().AddressBarReadonly;
-                this.CanDownloadBuild = this.configurationManager.GetConfiguration().ExperimentalFeatures.DynamicBuildLoading;
+                this.WebBrowser.IsEnabled = true;
+                this.BrowserEnabled = true;
+                await this.WebBrowser.EnsureCoreWebView2Async(coreWebView2Environment);
+                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) =>
                 {
@@ -209,8 +201,9 @@ namespace Daybreak.Controls
             }
             catch(Exception e)
             {
-                this.logger.LogError(e);
+                this.logger.LogError(e, $"Exception encountered when deserializing {nameof(BrowserPayload)}");
             }
+
             if (payload?.Key == BrowserPayload.PayloadKeys.ContextMenu)
             {
                 var contextMenuPayload = args.WebMessageAsJson.Deserialize<BrowserPayload<OnContextMenuPayload>>();
@@ -220,6 +213,11 @@ namespace Daybreak.Controls
                     return;
                 }
 
+                if (this.buildTemplateManager is null)
+                {
+                    return;
+                }
+
                 if (this.buildTemplateManager.IsTemplate(maybeTemplate) is false)
                 {
                     return;

Daybreak/Controls/Glyphs/LogsGlyph.xaml

@@ -0,0 +1,14 @@
+<UserControl x:Class="Daybreak.Controls.LogsGlyph"
+             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"
+             mc:Ignorable="d"
+             x:Name="_this"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Viewbox>
+        <Path Fill="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+            Data="m7,3l0,-1.00209c0,-1.09965 0.89762,-1.99791 2.00488,-1.99791l0.99024,0c1.11098,0 2.00488,0.8945 2.00488,1.99791l0,1.00209l2.00442,0c0.55074,0 0.99558,0.44725 0.99558,0.99896l0,1.00208c0,0.5563 -0.44574,0.99896 -0.99558,0.99896l-9.00884,0c-0.55074,0 -0.99558,-0.44725 -0.99558,-0.99896l0,-1.00208c0,-0.5563 0.44574,-0.99896 0.99558,-0.99896l2.00442,0l0,0zm8.99999,1l1.00259,0c1.10649,0 1.99742,0.89704 1.99742,2.00359l0,20.99282c0,1.11383 -0.89428,2.00359 -1.99742,2.00359l-15.00516,0c-1.10649,0 -1.99742,-0.89704 -1.99742,-2.00359l0,-20.99282c0,-1.11383 0.89428,-2.00359 1.99742,-2.00359l1.00259,0c-0.00001,0.00163 -0.00001,0.00325 -0.00001,0.00488l0,0.99024c0,1.10726 0.89354,2.00488 2.00276,2.00488l8.99448,0c1.10609,0 2.00276,-0.8939 2.00276,-2.00488l0,-0.99024c0,-0.00163 0,-0.00325 -0.00001,-0.00488l0,0l0,0zm-6.49999,-1c0.27614,0 0.5,-0.22386 0.5,-0.5c0,-0.27614 -0.22386,-0.5 -0.5,-0.5c-0.27614,0 -0.5,0.22386 -0.5,0.5c0,0.27614 0.22386,0.5 0.5,0.5l0,0zm-6.5,8l0,1l13,0l0,-1l-13,0l0,0zm0,3l0,1l13,0l0,-1l-13,0l0,0zm0,3l0,1l13,0l0,-1l-13,0l0,0zm0,3l0,1l13,0l0,-1l-13,0l0,0zm0,3l0,1l13,0l0,-1l-13,0l0,0z"></Path>
+    </Viewbox>
+</UserControl>

Daybreak/Controls/Glyphs/LogsGlyph.xaml.cs

@@ -0,0 +1,15 @@
+using System.Windows.Controls;
+
+namespace Daybreak.Controls
+{
+    /// <summary>
+    /// Interaction logic for LogsGlyph.xaml
+    /// </summary>
+    public partial class LogsGlyph : UserControl
+    {
+        public LogsGlyph()
+        {
+            InitializeComponent();
+        }
+    }
+}

Daybreak/Controls/Glyphs/StaticGlyph.xaml

@@ -0,0 +1,14 @@
+<UserControl x:Class="Daybreak.Controls.StaticGlyph"
+             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"
+             mc:Ignorable="d"
+             x:Name="_this"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Viewbox>
+        <Polygon Fill="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+            Points="209.89999389648438,829.800048828125 279.1999816894531,493.9000244140625 0,493.9000244140625 415.89996337890625,0 346.699951171875,335.8999938964844 625.800048828125,335.8999938964844"></Polygon>
+    </Viewbox>
+</UserControl>

Daybreak/Controls/Glyphs/StaticGlyph.xaml.cs

@@ -0,0 +1,15 @@
+using System.Windows.Controls;
+
+namespace Daybreak.Controls
+{
+    /// <summary>
+    /// Interaction logic for StaticGlyph.xaml
+    /// </summary>
+    public partial class StaticGlyph : UserControl
+    {
+        public StaticGlyph()
+        {
+            this.InitializeComponent();
+        }
+    }
+}

Daybreak/Controls/ImageViewer.xaml.cs

@@ -1,5 +1,4 @@
-using Daybreak.Utils;
-using System;
+using System;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
@@ -39,7 +38,7 @@ namespace Daybreak.Controls
             }
 
             nextVisible.Source = imageSource;
-            this.Transition(currentVisible, nextVisible);
+            Transition(currentVisible, nextVisible);
         }
 
         private Image CurrentVisible()
@@ -64,7 +63,7 @@ namespace Daybreak.Controls
                 return this.Image1;
             }
         }
-        private void Transition(Image from, Image to)
+        private static void Transition(Image from, Image to)
         {
             to.Visibility = Visibility.Visible;
             to.Opacity = 0;

Daybreak/Controls/SearchTextBox.xaml

@@ -0,0 +1,35 @@
+<UserControl x:Class="Daybreak.Controls.SearchTextBox"
+             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="BooleanToVisibilityConverter"></BooleanToVisibilityConverter>
+    </UserControl.Resources>
+    <Grid>
+        <TextBox Foreground="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=Foreground, Mode=OneWay}"
+                 FontSize="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontSize, Mode=OneWay}"
+                 FontFamily="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontFamily, Mode=OneWay}"
+                 FontStretch="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontStretch, Mode=OneWay}"
+                 FontWeight="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontWeight, Mode=OneWay}"
+                 FontStyle="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontStyle, Mode=OneWay}"
+                 TextChanged="TextBox_TextChanged"
+                 Background="Transparent"/>
+        <TextBlock  Margin="5, 0, 0, 0"
+                    Text="Search"
+                    Background="Transparent"
+                    Opacity="0.5"
+                    IsHitTestVisible="False"
+                    FontSize="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontSize, Mode=OneWay}"
+                    FontFamily="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontFamily, Mode=OneWay}"
+                    FontStretch="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontStretch, Mode=OneWay}"
+                    FontWeight="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontWeight, Mode=OneWay}"
+                    FontStyle="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=FontStyle, Mode=OneWay}"
+                    Foreground="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=Foreground, Mode=OneWay}"
+                    Visibility="{Binding RelativeSource={RelativeSource AncestorType=UserControl, Mode=FindAncestor}, Path=PlaceholderVisibility, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"/>
+    </Grid>
+</UserControl>

Daybreak/Controls/SearchTextBox.xaml.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Extensions;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Extensions;
+
+namespace Daybreak.Controls
+{
+    /// <summary>
+    /// Interaction logic for SearchTextBox.xaml
+    /// </summary>
+    public partial class SearchTextBox : UserControl
+    {
+        public event EventHandler<string> TextChanged;
+
+        [GenerateDependencyProperty(InitialValue = true)]
+        private bool placeholderVisibility;
+        [GenerateDependencyProperty]
+        private string searchText;
+
+        public SearchTextBox()
+        {
+            this.InitializeComponent();
+        }
+
+        private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
+        {
+            var searchText = e.Source.As<TextBox>().Text;
+            if (searchText.IsNullOrWhiteSpace())
+            {
+                this.PlaceholderVisibility = true;
+            }
+            else
+            {
+                this.PlaceholderVisibility = false;
+            }
+
+            this.SearchText = searchText;
+            this.TextChanged?.Invoke(this, searchText);
+        }
+    }
+}

Daybreak/Controls/Templates/AccountTemplate.xaml.cs

@@ -10,37 +10,21 @@ namespace Daybreak.Controls
     /// <summary>
     /// Interaction logic for AccountTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class AccountTemplate : UserControl
     {
-        public static readonly DependencyProperty UsernameProperty = DependencyPropertyExtensions.Register<AccountTemplate, string>(nameof(Username));
-        public static readonly DependencyProperty CharacterNameProperty = DependencyPropertyExtensions.Register<AccountTemplate, string>(nameof(CharacterName));
-        public static readonly DependencyProperty PasswordProperty = DependencyPropertyExtensions.Register<AccountTemplate, string>(nameof(Password));
-        public static readonly DependencyProperty IsDefaultProperty = DependencyPropertyExtensions.Register<AccountTemplate, bool>(nameof(IsDefault));
-
-
         public event EventHandler RemoveClicked;
         public event EventHandler DefaultClicked;
-
-        public string Username
-        {
-            get => this.GetTypedValue<string>(UsernameProperty);
-            set => this.SetValue(UsernameProperty, value);
-        }
-        public string Password
-        {
-            get => this.GetTypedValue<string>(PasswordProperty);
-            set => this.SetValue(PasswordProperty, value);
-        }
-        public string CharacterName
-        {
-            get => this.GetTypedValue<string>(CharacterNameProperty);
-            set => this.SetValue(CharacterNameProperty, value);
-        }
-        public bool IsDefault
-        {
-            get => this.GetTypedValue<bool>(IsDefaultProperty);
-            set => this.SetValue(IsDefaultProperty, value);
-        }
+        
+        [GenerateDependencyProperty]
+        private string username;
+        [GenerateDependencyProperty]
+        private string password;
+        [GenerateDependencyProperty]
+        private string characterName;
+        [GenerateDependencyProperty]
+        private bool isDefault;
 
         public AccountTemplate()
         {

Daybreak/Controls/Templates/AttributeTemplate.xaml.cs

@@ -10,26 +10,17 @@ namespace Daybreak.Controls
     /// <summary>
     /// Interaction logic for AttributeTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class AttributeTemplate : UserControl
     {
-        public readonly static DependencyProperty CanAddProperty =
-            DependencyPropertyExtensions.Register<AttributeTemplate, bool>(nameof(CanAdd), new PropertyMetadata(false));
-        public readonly static DependencyProperty CanSubtractProperty =
-            DependencyPropertyExtensions.Register<AttributeTemplate, bool>(nameof(CanSubtract), new PropertyMetadata(false));
-
         public event EventHandler<AttributeEntry> HelpClicked;
-
-        public bool CanAdd
-        {
-            get => this.GetTypedValue<bool>(CanAddProperty);
-            private set => this.SetValue(CanAddProperty, value);
-        }
-
-        public bool CanSubtract
-        {
-            get => this.GetTypedValue<bool>(CanSubtractProperty);
-            private set => this.SetValue(CanSubtractProperty, value);
-        }
+        public event EventHandler<AttributeEntry> AttributeChanged;
+        
+        [GenerateDependencyProperty(InitialValue = false)]
+        private bool canAdd;
+        [GenerateDependencyProperty(InitialValue = false)]
+        private bool canSubtract;
 
         public AttributeTemplate()
         {
@@ -60,6 +51,7 @@ namespace Daybreak.Controls
                 this.DataContext.As<AttributeEntry>().Points--;
                 this.CanSubtract = this.DataContext.As<AttributeEntry>().Points > 0;
                 this.CanAdd = true;
+                this.AttributeChanged?.Invoke(this, this.DataContext.As<AttributeEntry>());
             }
         }
 
@@ -70,6 +62,7 @@ namespace Daybreak.Controls
                 this.DataContext.As<AttributeEntry>().Points++;
                 this.CanAdd = this.DataContext.As<AttributeEntry>().Points < 12;
                 this.CanSubtract = true;
+                this.AttributeChanged?.Invoke(this, this.DataContext.As<AttributeEntry>());
             }
         }
 

Daybreak/Controls/Templates/BuildTemplate.xaml

@@ -4,11 +4,12 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
              xmlns:local="clr-namespace:Daybreak.Controls"
-             xmlns:interactivity="http://schemas.microsoft.com/expression/2010/interactivity"
+             xmlns:interactivity="http://schemas.microsoft.com/xaml/behaviors"
              xmlns:behaviors="clr-namespace:Daybreak.Behaviors"
              xmlns:converters="clr-namespace:Daybreak.Converters"
              mc:Ignorable="d"
              x:Name="_this"
+             Unloaded="BuildTemplate_Unloaded"
              d:DesignHeight="450" d:DesignWidth="800">
     <Grid Background="Transparent" MouseLeftButtonDown="Grid_MouseLeftButtonDown">
         <Grid.RowDefinitions>
@@ -75,7 +76,7 @@
                      HorizontalContentAlignment="Stretch" BorderThickness="0">
                 <ListBox.ItemTemplate>
                     <DataTemplate>
-                        <local:AttributeTemplate HelpClicked="AttributeTemplate_HelpClicked"></local:AttributeTemplate>
+                        <local:AttributeTemplate HelpClicked="AttributeTemplate_HelpClicked" AttributeChanged="AttributeTemplate_AttributeChanged"></local:AttributeTemplate>
                     </DataTemplate>
                 </ListBox.ItemTemplate>
             </ListBox>
@@ -95,42 +96,42 @@
                 <RowDefinition Height="*"></RowDefinition>
                 <RowDefinition Height="auto"></RowDefinition>
             </Grid.RowDefinitions>
-            <local:SkillTemplate Grid.Column="0"
+            <local:SkillTemplate Grid.Column="0" x:Name="SkillTemplate0"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill0, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="1"
+            <local:SkillTemplate Grid.Column="1" x:Name="SkillTemplate1"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill1, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="2"
+            <local:SkillTemplate Grid.Column="2" x:Name="SkillTemplate2"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill2, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="3"
+            <local:SkillTemplate Grid.Column="3" x:Name="SkillTemplate3"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill3, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="4"
+            <local:SkillTemplate Grid.Column="4" x:Name="SkillTemplate4"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill4, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="5"
+            <local:SkillTemplate Grid.Column="5" x:Name="SkillTemplate5"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill5, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="6"
+            <local:SkillTemplate Grid.Column="6" x:Name="SkillTemplate6"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill6, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
                                  RemoveClicked="SkillTemplate_RemoveClicked"></local:SkillTemplate>
-            <local:SkillTemplate Grid.Column="7"
+            <local:SkillTemplate Grid.Column="7" x:Name="SkillTemplate7"
                                  Foreground="White" Cursor="Hand"
                                  FontSize="22" DataContext="{Binding ElementName=_this, Path=Skill7, Mode=TwoWay}"
                                  VerticalAlignment="Stretch" Clicked="SkillTemplate_Clicked"
@@ -156,14 +157,30 @@
             <local:ChromiumBrowserWrapper x:Name="SkillBrowser" ControlsEnabled="False" Width="0" AddressBarReadonly="True" CanNavigate="True"></local:ChromiumBrowserWrapper>
         </Grid>
         <Grid Grid.Column="1" Grid.RowSpan="6">
-            <ListView x:Name="SkillsListView" Background="Transparent" Width="0"
-                ItemsSource="{Binding ElementName=_this, Path=AvailableSkills, Mode=OneWay}" MouseDoubleClick="ListView_MouseDoubleClick">
-                <ListView.ItemTemplate>
-                    <DataTemplate>
-                        <TextBlock FontSize="16" Foreground="White" TextWrapping="Wrap" Text="{Binding Name}"></TextBlock>
-                    </DataTemplate>
-                </ListView.ItemTemplate>
-            </ListView>
+            <Grid x:Name="SkillListContainer">
+                <Grid.RowDefinitions>
+                    <RowDefinition Height="auto"></RowDefinition>
+                    <RowDefinition Height="*"></RowDefinition>
+                </Grid.RowDefinitions>
+                <local:SearchTextBox    FontSize="20"
+                                        Foreground="White"
+                                        Background="Transparent"
+                                        SearchText="{Binding ElementName=_this, Path=SkillSearchText, Mode=TwoWay}"
+                                        TextChanged="SearchTextBox_TextChanged"></local:SearchTextBox>
+                <ScrollViewer VerticalScrollBarVisibility="Hidden"
+                              HorizontalScrollBarVisibility="Disabled"
+                              Grid.Row="1"
+                              PreviewMouseWheel="ScrollViewer_PreviewMouseWheel">
+                    <ListView x:Name="SkillsListView" Background="Transparent"
+                        ItemsSource="{Binding ElementName=_this, Path=AvailableSkills, Mode=OneWay}" MouseDoubleClick="ListView_MouseDoubleClick">
+                        <ListView.ItemTemplate>
+                            <DataTemplate>
+                                <TextBlock FontSize="16" Foreground="White" TextWrapping="Wrap" Text="{Binding Name}"></TextBlock>
+                            </DataTemplate>
+                        </ListView.ItemTemplate>
+                    </ListView>
+                </ScrollViewer>
+            </Grid>
         </Grid>
     </Grid>
 </UserControl>

Daybreak/Controls/Templates/BuildTemplate.xaml.cs

@@ -1,103 +1,64 @@
-using Daybreak.Launch;
+using Daybreak.Configuration;
 using Daybreak.Models.Builds;
+using Daybreak.Services.BuildTemplates;
 using Daybreak.Services.IconRetrieve;
-using System.Collections;
+using Microsoft.Extensions.Logging;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Configuration;
+using System.Core.Extensions;
 using System.Extensions;
-using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
+using System.Threading;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
+using Utils;
 
 namespace Daybreak.Controls
 {
     /// <summary>
     /// Interaction logic for BuildTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class BuildTemplate : UserControl
     {
         private const string InfoNamePlaceholder = "[NAME]";
         private const string BaseAddress = $"https://wiki.guildwars.com/wiki/{InfoNamePlaceholder}";
 
-        public readonly static DependencyProperty PrimaryProfessionProperty =
-            DependencyPropertyExtensions.Register<BuildTemplate, Profession>(nameof(PrimaryProfession), new PropertyMetadata(Profession.None));
-        public readonly static DependencyProperty SecondaryProfessionProperty =
-            DependencyPropertyExtensions.Register<BuildTemplate, Profession>(nameof(SecondaryProfession), new PropertyMetadata(Profession.None));
-        public readonly static DependencyProperty Skill0Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill0), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill1Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill1), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill2Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill2), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill3Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill3), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill4Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill4), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill5Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill5), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill6Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill6), new PropertyMetadata(Skill.NoSkill));
-        public readonly static DependencyProperty Skill7Property =
-            DependencyPropertyExtensions.Register<BuildTemplate, Skill>(nameof(Skill7), new PropertyMetadata(Skill.NoSkill));
-
+        private bool suppressBuildChanged = false;
+        private bool loadedProperties = false;
+        private IIconBrowser iconBrowser;
         private BuildEntry loadedBuild;
         private SkillTemplate selectingSkillTemplate;
+        private CancellationTokenSource cancellationTokenSource = new();
 
-        public Profession PrimaryProfession
-        {
-            get => this.GetTypedValue<Profession>(PrimaryProfessionProperty);
-            set => this.SetValue(PrimaryProfessionProperty, value);
-        }
-        public Profession SecondaryProfession
-        {
-            get => this.GetTypedValue<Profession>(SecondaryProfessionProperty);
-            set => this.SetValue(SecondaryProfessionProperty, value);
-        }
-        public Skill Skill0
-        {
-            get => this.GetTypedValue<Skill>(Skill0Property);
-            set => this.SetValue(Skill0Property, value);
-        }
-        public Skill Skill1
-        {
-            get => this.GetTypedValue<Skill>(Skill1Property);
-            set => this.SetValue(Skill1Property, value);
-        }
-        public Skill Skill2
-        {
-            get => this.GetTypedValue<Skill>(Skill2Property);
-            set => this.SetValue(Skill2Property, value);
-        }
-        public Skill Skill3
-        {
-            get => this.GetTypedValue<Skill>(Skill3Property);
-            set => this.SetValue(Skill3Property, value);
-        }
-        public Skill Skill4
-        {
-            get => this.GetTypedValue<Skill>(Skill4Property);
-            set => this.SetValue(Skill4Property, value);
-        }
-        public Skill Skill5
-        {
-            get => this.GetTypedValue<Skill>(Skill5Property);
-            set => this.SetValue(Skill5Property, value);
-        }
-        public Skill Skill6
-        {
-            get => this.GetTypedValue<Skill>(Skill6Property);
-            set => this.SetValue(Skill6Property, value);
-        }
-        public Skill Skill7
-        {
-            get => this.GetTypedValue<Skill>(Skill7Property);
-            set => this.SetValue(Skill7Property, value);
-        }
+        public event EventHandler BuildChanged;
+
+        [GenerateDependencyProperty]
+        private string skillSearchText;
+        [GenerateDependencyProperty]
+        private Profession primaryProfession;
+        [GenerateDependencyProperty]
+        private Profession secondaryProfession;
+        [GenerateDependencyProperty]
+        private Skill skill0;
+        [GenerateDependencyProperty]
+        private Skill skill1;
+        [GenerateDependencyProperty]
+        private Skill skill2;
+        [GenerateDependencyProperty]
+        private Skill skill3;
+        [GenerateDependencyProperty]
+        private Skill skill4;
+        [GenerateDependencyProperty]
+        private Skill skill5;
+        [GenerateDependencyProperty]
+        private Skill skill6;
+        [GenerateDependencyProperty]
+        private Skill skill7;
         public ObservableCollection<Skill> AvailableSkills { get; } = new ObservableCollection<Skill>();
         public ObservableCollection<AttributeEntry> Attributes { get; } = new ObservableCollection<AttributeEntry>();
         public ObservableCollection<Profession> Professions { get; } = new ObservableCollection<Profession>(Profession.Professions);
@@ -105,12 +66,40 @@ namespace Daybreak.Controls
         public BuildTemplate()
         {
             this.InitializeComponent();
-            this.DataContextChanged += BuildTemplate_DataContextChanged;
+            this.InitializeProperties();
+            this.DataContextChanged += this.BuildTemplate_DataContextChanged;
+        }
+
+        public async void InitializeTemplate(
+            IIconCache iconRetriever,
+            IIconBrowser iconBrowser,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
+            IBuildTemplateManager buildTemplateManager,
+            ILogger<ChromiumBrowserWrapper> logger)
+        {
+            this.iconBrowser = iconBrowser.ThrowIfNull();
+            await this.SkillBrowser.InitializeBrowser(liveOptions, buildTemplateManager, logger);
+            this.SkillTemplate0.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate1.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate2.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate3.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate4.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate5.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate6.InitializeSkillTemplate(iconRetriever);
+            this.SkillTemplate7.InitializeSkillTemplate(iconRetriever);
+
+            this.HideSkillListView();
+            this.HideInfoBrowser();
         }
 
         protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
         {
             base.OnPropertyChanged(e);
+            if (this.loadedProperties is false)
+            {
+                return;
+            }
+
             if (e.Property == PrimaryProfessionProperty || e.Property == SecondaryProfessionProperty)
             {
                 if (e.Property == PrimaryProfessionProperty)
@@ -121,9 +110,57 @@ namespace Daybreak.Controls
                 {
                     this.loadedBuild.Build.Secondary = this.SecondaryProfession;
                 }
+
                 this.LoadSkills();
                 this.LoadAttributes();
+                if (this.suppressBuildChanged is false)
+                {
+                    this.BuildChanged?.Invoke(this, new EventArgs());
+                }
             }
+
+            if (e.Property == Skill0Property ||
+                e.Property == Skill1Property ||
+                e.Property == Skill2Property ||
+                e.Property == Skill3Property ||
+                e.Property == Skill4Property ||
+                e.Property == Skill5Property ||
+                e.Property == Skill6Property ||
+                e.Property == Skill7Property)
+            {
+                if (this.suppressBuildChanged is false)
+                {
+                    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;
+                    this.BuildChanged?.Invoke(this, new EventArgs());
+                }
+            }
+        }
+
+        private void BuildTemplate_Unloaded(object sender, RoutedEventArgs e)
+        {
+            this.cancellationTokenSource.Cancel();
+        }
+
+        private void InitializeProperties()
+        {
+            this.PrimaryProfession = Profession.None;
+            this.SecondaryProfession = Profession.None;
+            this.Skill0 = Skill.NoSkill;
+            this.Skill1 = Skill.NoSkill;
+            this.Skill2 = Skill.NoSkill;
+            this.Skill3 = Skill.NoSkill;
+            this.Skill4 = Skill.NoSkill;
+            this.Skill5 = Skill.NoSkill;
+            this.Skill6 = Skill.NoSkill;
+            this.Skill7 = Skill.NoSkill;
+            this.loadedProperties = true;
         }
 
         private void BuildTemplate_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
@@ -174,55 +211,65 @@ 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)
+                .Where(s => this.SkillSearchText.IsNullOrWhiteSpace() ?
+                            true :
+                            StringUtils.MatchesSearchString(s.Name.Replace("\"", "").Replace("!", ""), this.SkillSearchText.Replace("\"", "").Replace("!", "")))
                 .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;
@@ -231,6 +278,7 @@ namespace Daybreak.Controls
 
         private void LoadBuild()
         {
+            this.suppressBuildChanged = true;
             var build = this.DataContext.As<BuildEntry>();
             this.loadedBuild = build;
             this.PrimaryProfession = build.Build.Primary;
@@ -243,6 +291,7 @@ namespace Daybreak.Controls
             this.Skill5 = build.Build.Skills[5];
             this.Skill6 = build.Build.Skills[6];
             this.Skill7 = build.Build.Skills[7];
+            this.suppressBuildChanged = false;
         }
 
         private void BrowseToInfo(string infoName)
@@ -254,24 +303,30 @@ 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.SkillListContainer.Width = 0;
+            }
         }
 
         private void HideInfoBrowser()
         {
-            this.SkillBrowser.Width = 0;
+            if (this.SkillBrowser.BrowserSupported is true)
+            {
+                this.SkillBrowser.Width = 0;
+            }
         }
 
         private void ShowSkillListView()
         {
             this.SkillBrowser.Width = 0;
-            this.SkillsListView.Width = 400;
+            this.SkillListContainer.Width = 400;
         }
 
         private void HideSkillListView()
         {
-            this.SkillsListView.Width = 0;
+            this.SkillListContainer.Width = 0;
         }
 
         private void HelpButtonPrimary_Clicked(object sender, System.EventArgs e)
@@ -281,7 +336,7 @@ namespace Daybreak.Controls
                 return;
             }
 
-            this.BrowseToInfo(PrimaryProfession.Name);
+            this.BrowseToInfo(this.PrimaryProfession.Name);
             if (e is RoutedEventArgs routedEventArgs)
             {
                 routedEventArgs.Handled = true;
@@ -307,11 +362,17 @@ namespace Daybreak.Controls
             this.BrowseToInfo(e.Attribute.Name);
         }
 
+        private void AttributeTemplate_AttributeChanged(object sender, AttributeEntry e)
+        {
+            this.BuildChanged?.Invoke(this, new EventArgs());
+        }
+
         private void SkillTemplate_Clicked(object sender, RoutedEventArgs e)
         {
             var skill = sender.As<SkillTemplate>().DataContext.As<Skill>();
             if (skill == Skill.NoSkill)
             {
+                this.SkillSearchText = string.Empty;
                 this.ShowSkillListView();
                 this.selectingSkillTemplate = sender.As<SkillTemplate>();
             }
@@ -319,9 +380,15 @@ namespace Daybreak.Controls
             {
                 this.BrowseToInfo(skill.Name);
             }
+
             e.Handled = true;
         }
 
+        private void SearchTextBox_TextChanged(object sender, string e)
+        {
+            this.LoadSkills();
+        }
+
         private void SkillTemplate_RemoveClicked(object sender, System.EventArgs e)
         {
             sender.As<SkillTemplate>().DataContext = Skill.NoSkill;
@@ -337,14 +404,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)
@@ -363,5 +430,16 @@ namespace Daybreak.Controls
                     sender.As<ListView>().Items.Count;
             }
         }
+
+        private void ScrollViewer_PreviewMouseWheel(object sender, System.Windows.Input.MouseWheelEventArgs e)
+        {
+            if (sender is not ScrollViewer scrollViewer)
+            {
+                return;
+            }
+
+            e.Handled = true;
+            scrollViewer.ScrollToVerticalOffset(scrollViewer.VerticalOffset - e.Delta);
+        }
     }
 }

Daybreak/Controls/Templates/GuildwarsPathTemplate.xaml.cs

@@ -11,24 +11,17 @@ namespace Daybreak.Controls
     /// <summary>
     /// Interaction logic for GuildwarsPathTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class GuildwarsPathTemplate : UserControl
     {
-        public static readonly DependencyProperty PathProperty = DependencyPropertyExtensions.Register<GuildwarsPathTemplate, string>(nameof(Path));
-        public static readonly DependencyProperty IsDefaultProperty = DependencyPropertyExtensions.Register<GuildwarsPathTemplate, bool>(nameof(IsDefault));
-
         public event EventHandler RemoveClicked;
         public event EventHandler DefaultClicked;
 
-        public string Path
-        {
-            get => this.GetTypedValue<string>(PathProperty);
-            set => this.SetValue(PathProperty, value);
-        }
-        public bool IsDefault
-        {
-            get => this.GetTypedValue<bool>(IsDefaultProperty);
-            set => this.SetValue(IsDefaultProperty, value);
-        }
+        [GenerateDependencyProperty]
+        private string path;
+        [GenerateDependencyProperty]
+        private bool isDefault;
 
         public GuildwarsPathTemplate()
         {

Daybreak/Controls/Templates/LogMessageTemplate.xaml

@@ -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>

Daybreak/Controls/Templates/LogMessageTemplate.xaml.cs

@@ -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;
+            }
+        }
+    }
+}

Daybreak/Controls/Templates/ScreenTemplate.xaml.cs

@@ -11,26 +11,16 @@ namespace Daybreak.Controls.Templates
     /// <summary>
     /// Interaction logic for ScreenTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class ScreenTemplate : UserControl
     {
-        public static readonly DependencyProperty ScreenIdProperty =
-            DependencyPropertyExtensions.Register<ScreenTemplate, string>(nameof(ScreenId));
-        public static readonly DependencyProperty HighlightProperty =
-            DependencyPropertyExtensions.Register<ScreenTemplate, Brush>(nameof(Highlight));
-
         public event EventHandler<Screen> Clicked;
 
-        public string ScreenId
-        {
-            get => this.GetTypedValue<string>(ScreenIdProperty);
-            set => this.SetValue(ScreenIdProperty, value);
-        }
-
-        public Brush Highlight
-        {
-            get => this.GetTypedValue<Brush>(HighlightProperty);
-            set => this.SetValue(HighlightProperty, value);
-        }
+        [GenerateDependencyProperty]
+        private string screenId;
+        [GenerateDependencyProperty]
+        private Brush highlight;
 
         public ScreenTemplate()
         {

Daybreak/Controls/Templates/SkillTemplate.xaml

@@ -1,8 +1,9 @@
 <UserControl x:Class="Daybreak.Controls.SkillTemplate"
              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:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:webview="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
              xmlns:local="clr-namespace:Daybreak.Controls"
              mc:Ignorable="d" 
              x:Name="_this"

Daybreak/Controls/Templates/SkillTemplate.xaml.cs

@@ -1,10 +1,6 @@
-using Daybreak.Launch;
-using Daybreak.Models.Builds;
+using Daybreak.Models.Builds;
 using Daybreak.Services.IconRetrieve;
 using System;
-using System.Extensions;
-using System.IO;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
@@ -16,49 +12,48 @@ namespace Daybreak.Controls
     /// <summary>
     /// Interaction logic for SkillTemplate.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class SkillTemplate : UserControl
     {
-        public readonly static DependencyProperty ImageSourceProperty =
-            DependencyPropertyExtensions.Register<SkillTemplate, ImageSource>(nameof(ImageSource));
-        public readonly static DependencyProperty BorderOpacityProperty =
-            DependencyPropertyExtensions.Register<SkillTemplate, double>(nameof(BorderOpacity), new PropertyMetadata(0d));
-
         public event EventHandler<RoutedEventArgs> Clicked;
         public event EventHandler RemoveClicked;
 
-        private readonly IIconRetriever iconRetriever;
+        private IIconCache iconRetriever;
 
-        public ImageSource ImageSource
-        {
-            get => this.GetTypedValue<ImageSource>(ImageSourceProperty);
-            set => this.SetValue(ImageSourceProperty, value);
-        }
-        public double BorderOpacity
-        {
-            get => this.GetTypedValue<double>(BorderOpacityProperty);
-            set => this.SetValue(BorderOpacityProperty, value);
-        }
+        [GenerateDependencyProperty]
+        private ImageSource imageSource;
+        [GenerateDependencyProperty]
+        private double borderOpacity;
 
         public SkillTemplate()
         {
-            this.iconRetriever = Launcher.ApplicationServiceManager.GetService<IIconRetriever>();
             this.InitializeComponent();
             this.DataContextChanged += SkillTemplate_DataContextChanged;
         }
 
-        private void SkillTemplate_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
+        public void InitializeSkillTemplate(IIconCache iconRetriever)
         {
+            this.iconRetriever = iconRetriever;
+            this.SkillTemplate_DataContextChanged(this, new DependencyPropertyChangedEventArgs(UserControl.DataContextProperty, null, this.DataContext));
+        }
+
+        private async void SkillTemplate_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
+        {
+            if (this.iconRetriever is null)
+            {
+                return;
+            }
+
             if (e.NewValue is Skill skill)
             {
                 if (skill != Skill.NoSkill)
                 {
-                    Task.Run(() => GetImageStream(skill)).ContinueWith((previousTask) =>
+                    var maybeUri = await this.iconRetriever.GetIconUri(skill).ConfigureAwait(true);
+                    if (maybeUri.ExtractValue() is Uri uri)
                     {
-                        this.Dispatcher.Invoke(() =>
-                        {
-                            this.ImageSource = GetImageSource(previousTask.Result);
-                        });
-                    });
+                        this.ImageSource = new BitmapImage(uri);
+                    }
                 }
                 else if (this.ImageSource is not null)
                 {
@@ -95,27 +90,5 @@ namespace Daybreak.Controls
 
             return false;
         }
-        private async Task<Stream> GetImageStream(Skill skill)
-        {
-            var maybeStream = await this.iconRetriever.GetIcon(skill);
-            return maybeStream.ExtractValue();
-        }
-        private ImageSource GetImageSource(Stream stream)
-        {
-            if (stream is null)
-            {
-                return null;
-            }
-
-            return this.Dispatcher.Invoke(() =>
-            {
-                var bitmapImage = new BitmapImage();
-                bitmapImage.BeginInit();
-                bitmapImage.StreamSource = stream;
-                bitmapImage.CacheOption = BitmapCacheOption.OnDemand;
-                bitmapImage.EndInit();
-                return bitmapImage;
-            });
-        }
     }
 }

Daybreak/Converters/BooleanToVisibilityConverter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Extensions;
 using System.Globalization;
 using System.Windows;
 using System.Windows.Data;
@@ -19,7 +20,7 @@ namespace Daybreak.Converters
 
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            return GetVisibility(value);
+            return this.GetVisibility(value);
         }
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
@@ -29,17 +30,24 @@ namespace Daybreak.Converters
 
         private object GetVisibility(object value)
         {
-            if (!(value is bool))
-                return DependencyProperty.UnsetValue;
-            bool objValue = (bool)value;
+            if (value is not bool)
+            {
+                return this.IsHidden ?
+                    Visibility.Hidden :
+                    Visibility.Collapsed;
+            }
+
+            var objValue = value.Cast<bool>();
             if ((objValue && TriggerValue && IsHidden) || (!objValue && !TriggerValue && IsHidden))
             {
                 return Visibility.Hidden;
             }
+
             if ((objValue && TriggerValue && !IsHidden) || (!objValue && !TriggerValue && !IsHidden))
             {
                 return Visibility.Collapsed;
             }
+
             return Visibility.Visible;
         }
     }

Daybreak/Daybreak.csproj

@@ -1,27 +1,35 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net6.0-windows</TargetFramework>
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <Platforms>AnyCPU</Platforms>
-    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
     <LangVersion>preview</LangVersion>
     <ApplicationIcon>Daybreak.ico</ApplicationIcon>
-    <Version>0.8.2</Version>
+    <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
+    <Version>0.9.4</Version>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="HtmlAgilityPack" Version="1.11.32" />
-    <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.818.41" />
+    <PackageReference Include="LiteDB" Version="5.0.12" />
+    <PackageReference Include="Microsoft.CorrelationVector" Version="1.0.42" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.1264.42" />
+    <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.39" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="Slim" Version="1.2.1" />
-    <PackageReference Include="System.Windows.Interactivity.WPF" Version="2.0.20525" />
-    <PackageReference Include="SystemExtensions.NetStandard" Version="1.1.4" />
+    <PackageReference Include="NReco.Logging.File" Version="1.1.5" />
+    <PackageReference Include="securifybv.ShellLink" Version="0.1.0" />
+    <PackageReference Include="Slim" Version="1.7.3" />
+    <PackageReference Include="SystemExtensions.NetCore" Version="1.0.1" />
+    <PackageReference Include="SystemExtensions.NetStandard" Version="1.5.0" />
     <PackageReference Include="WCL" Version="1.0.2" />
-    <PackageReference Include="WpfExtended" Version="0.2.0" />
-    <PackageReference Include="WpfScreenHelper" Version="1.0.0" />
+    <PackageReference Include="WpfExtended" Version="0.6.2" />
+    <PackageReference Include="WpfExtended.SourceGeneration" Version="0.1.1" />
+    <PackageReference Include="WpfScreenHelper" Version="2.0.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -37,6 +45,9 @@
     <Compile Update="Controls\Buttons\CancelButton.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="Views\IconDownloadView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>
@@ -60,6 +71,22 @@
       <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="Views\IconDownloadView.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+      <SubType>Designer</SubType>
+    </Page>
   </ItemGroup>
 
+  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
+    <Exec Command="echo.&gt;$(Version).version" />
+  </Target>
+
+  <Target Name="RemoveDuplicateAnalyzers" BeforeTargets="CoreCompile">
+		<!-- Work around https://github.com/dotnet/wpf/issues/6792 -->
+    <ItemGroup>
+      <FilteredAnalyzer Include="@(Analyzer-&gt;Distinct())" />
+      <Analyzer Remove="@(Analyzer)" />
+      <Analyzer Include="@(FilteredAnalyzer)" />
+    </ItemGroup>
+  </Target>
 </Project>

Daybreak/Launch/Launcher.cs

@@ -1,17 +1,13 @@
 using Daybreak.Configuration;
 using Daybreak.Exceptions;
-using Daybreak.Services.ApplicationLifetime;
-using Daybreak.Services.Logging;
 using Daybreak.Services.ViewManagement;
-using Daybreak.Utils;
-using Microsoft.Web.WebView2.Core;
-using Microsoft.Web.WebView2.Wpf;
+using Microsoft.Extensions.Logging;
 using Slim;
 using System;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Extensions;
 
@@ -19,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]
@@ -28,10 +24,14 @@ namespace Daybreak.Launch
             return LaunchMainWindow();
         }
 
+        protected override void SetupServiceManager(IServiceManager serviceManager)
+        {
+            ProjectConfiguration.RegisterResolvers(serviceManager);
+        }
         protected override void RegisterServices(IServiceProducer serviceProducer)
         {
             ProjectConfiguration.RegisterServices(this.ServiceManager);
-            ProjectConfiguration.RegisterLifetimeServices(this.ServiceManager.GetService<IApplicationLifetimeManager>());
+            ServiceManager.BuildSingletons();
             ProjectConfiguration.RegisterViews(this.ServiceManager.GetService<IViewManager>());
         }
         protected override bool HandleException(Exception e)
@@ -41,10 +41,23 @@ namespace Daybreak.Launch
                 return false;
             }
 
-            this.ServiceManager.GetService<ILogger>().LogCritical(e);
+            if (this.logger is null)
+            {
+                return false;
+            }
+
             if (e is FatalException fatalException)
             {
+                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.logger.LogCritical(e, $"{nameof(FatalException)} encountered. Closing application");
+                MessageBox.Show(innerFatalException.ToString());
+                File.WriteAllText("crash.log", e.ToString());
                 return false;
             }
             else if (e is AggregateException aggregateException)
@@ -54,24 +67,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()
         {
-            ApplicationServiceManager = this.ServiceManager;
-            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()

Daybreak/Launch/MainWindow.xaml

@@ -2,7 +2,8 @@
         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:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:webview="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
         xmlns:local="clr-namespace:Daybreak.Launch"
         xmlns:wcl="clr-namespace:WCL;assembly=WCL"
         mc:Ignorable="d"
@@ -86,18 +87,26 @@
                  HorizontalAlignment="Right" Margin="0, 0, 20, 30" FontSize="22" Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
                  Clicked="CreditTextBox_MouseLeftButtonDown" Cursor="Hand"></controls:OpaqueButton>
         <WrapPanel Grid.Row="1"  Margin="0, 0, 20, 10" VerticalAlignment="Bottom" HorizontalAlignment="Right">
-            <TextBox Grid.Row="1" Background="Transparent" BorderBrush="Transparent" BorderThickness="0" Opacity="0.6"
-                     Text="{Binding ElementName=_this, Path=CurrentVersionText, Mode=OneWay}" IsReadOnly="True" FontSize="10"
-                     Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"></TextBox>
-            <TextBox Grid.Row="1" Background="Transparent" Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}" 
+            <controls:OpaqueButton Grid.Row="1" Background="Transparent" BorderBrush="Transparent" BorderThickness="0" Opacity="0.6"
+                     Text="{Binding ElementName=_this, Path=CurrentVersionText, Mode=OneWay}" FontSize="10"
+                     Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+                     Clicked="VersionText_Clicked"></controls:OpaqueButton>
+            <controls:OpaqueButton Grid.Row="1" Background="Transparent" Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}" 
                      Opacity="0.6" Text=" - " FontSize="10" BorderBrush="Transparent" BorderThickness="0"
-                     Visibility="{Binding ElementName=_this, Path=IsRunningAsAdmin, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"></TextBox>
-            <TextBox Grid.Row="1" Background="Transparent" Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}" 
+                     Visibility="{Binding ElementName=_this, Path=IsRunningAsAdmin, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"
+                     Clicked="VersionText_Clicked"></controls:OpaqueButton>
+            <controls:OpaqueButton Grid.Row="1" Background="Transparent" Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}" 
                      Opacity="0.6" Text="[Admin]" FontSize="10" BorderBrush="Transparent" BorderThickness="0"
-                     Visibility="{Binding ElementName=_this, Path=IsRunningAsAdmin, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"></TextBox>
+                     Visibility="{Binding ElementName=_this, Path=IsRunningAsAdmin, Mode=OneWay, Converter={StaticResource BooleanToVisibilityConverter}}"
+                     Clicked="VersionText_Clicked"></controls:OpaqueButton>
         </WrapPanel>
         <Grid x:Name="Container" Grid.Row="1">
         </Grid>
         <wcl:Border OnResize="Border_OnResize" Grid.RowSpan="2" Active="True"></wcl:Border>
+        <webview:WebView2 x:Name="BackgroundWebView"
+                                         VerticalAlignment="Center"
+                                         HorizontalAlignment="Center"
+                                         Visibility="Collapsed"
+                                         Grid.Row="1"></webview:WebView2>
     </Grid>
 </Window>

Daybreak/Launch/MainWindow.xaml.cs

@@ -1,12 +1,15 @@
-using Daybreak.Services.Bloogum;
+using Daybreak.Configuration;
+using Daybreak.Services.Bloogum;
+using Daybreak.Services.IconRetrieve;
 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.Core.Extensions;
 using System.Diagnostics;
 using System.Extensions;
 using System.Threading;
@@ -22,58 +25,53 @@ namespace Daybreak.Launch
     /// <summary>
     /// Interaction logic for MainWindow.xaml
     /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "Fields used by source generator for DependencyProperty")]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class MainWindow : Window
     {
-        public static readonly DependencyProperty CreditTextProperty = DependencyPropertyExtensions.Register<MainWindow, string>(nameof(CreditText));
-        public static readonly DependencyProperty CurrentVersionTextProperty = DependencyPropertyExtensions.Register<MainWindow, string>(nameof(CurrentVersionText));
-        public static readonly DependencyProperty IsRunningAsAdminProperty = DependencyPropertyExtensions.Register<MainWindow, bool>(nameof(IsRunningAsAdmin));
-
         private readonly IViewManager viewManager;
         private readonly IScreenshotProvider screenshotProvider;
         private readonly IBloogumClient bloogumClient;
         private readonly IApplicationUpdater applicationUpdater;
         private readonly IPrivilegeManager privilegeManager;
+        private readonly IIconDownloader iconDownloader;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly CancellationTokenSource cancellationToken = new();
 
-        public string CreditText
-        {
-            get => this.GetTypedValue<string>(CreditTextProperty);
-            set => this.SetValue(CreditTextProperty, value);
-        }
-
-        public string CurrentVersionText
-        {
-            get => this.GetTypedValue<string>(CurrentVersionTextProperty);
-            set => this.SetValue(CurrentVersionTextProperty, value);
-        }
-
-        public bool IsRunningAsAdmin
-        {
-            get => this.GetTypedValue<bool>(IsRunningAsAdminProperty);
-            set => this.SetValue(IsRunningAsAdminProperty, value);
-        }
+        [GenerateDependencyProperty]
+        private string creditText;
+        [GenerateDependencyProperty]
+        private string currentVersionText;
+        [GenerateDependencyProperty]
+        private bool isRunningAsAdmin;
 
         public MainWindow(
             IViewManager viewManager,
             IScreenshotProvider screenshotProvider,
             IBloogumClient bloogumClient,
             IApplicationUpdater applicationUpdater,
-            IPrivilegeManager privilegeManager)
+            IPrivilegeManager privilegeManager,
+            IIconDownloader iconDownloader,
+            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.viewManager = viewManager.ThrowIfNull();
+            this.screenshotProvider = screenshotProvider.ThrowIfNull();
+            this.bloogumClient = bloogumClient.ThrowIfNull();
+            this.applicationUpdater = applicationUpdater.ThrowIfNull();
+            this.privilegeManager = privilegeManager.ThrowIfNull();
+            this.iconDownloader = iconDownloader.ThrowIfNull();
+            this.liveOptions = liveOptions.ThrowIfNull();
             this.InitializeComponent();
-            this.CurrentVersionText = this.applicationUpdater.CurrentVersion;
+            this.CurrentVersionText = this.applicationUpdater.CurrentVersion.ToString();
             this.IsRunningAsAdmin = this.privilegeManager.AdminPrivileges;
         }
 
+
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             this.SetupImageCycle();
             this.CheckForUpdates();
+            this.SetupBackgroundBrowser();
         }
 
         private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
@@ -109,6 +107,11 @@ namespace Daybreak.Launch
             NativeMethods.SendMessage(new WindowInteropHelper(this).Handle, NativeMethods.WM_SYSCOMMAND, (IntPtr)e, IntPtr.Zero);
         }
 
+        private void SetupBackgroundBrowser()
+        {
+            this.iconDownloader.SetBrowser(this.BackgroundWebView);
+        }
+
         private void SetupImageCycle()
         {
             TaskExtensions.RunPeriodicAsync(() => this.Dispatcher.Invoke(() => this.UpdateRandomImage()), TimeSpan.Zero, TimeSpan.FromSeconds(15), this.cancellationToken.Token);
@@ -152,6 +155,11 @@ namespace Daybreak.Launch
             }
         }
 
+        private void VersionText_Clicked(object sender, EventArgs e)
+        {
+            this.viewManager.ShowView<VersionManagementView>();
+        }
+
         private void SetImage(ImageSource imageSource)
         {
             this.ImageViewer.ShowImage(imageSource);
@@ -172,7 +180,7 @@ namespace Daybreak.Launch
 
         private async void CheckForUpdates()
         {
-            var updateAvailable = 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>();

Daybreak/Models/Browser/BrowserPayload.cs

@@ -8,6 +8,7 @@ namespace Daybreak.Models.Browser
         [JsonConverter(typeof(StringEnumConverter))]
         public enum PayloadKeys
         {
+            None,
             ContextMenu
         }
 

Daybreak/Models/Builds/Skill.cs

@@ -143,7 +143,7 @@ namespace Daybreak.Models.Builds
         public static Skill Flurry { get; } = new() { Id = 344, Name = "Flurry", Profession = Profession.Warrior };
         public static Skill Frenzy { get; } = new() { Id = 346, Name = "Frenzy", Profession = Profession.Warrior };
         public static Skill Coward { get; } = new() { Id = 869, Name = "\"Coward!\"", Profession = Profession.Warrior };
-        public static Skill OnYourKnees { get; } = new() { Id = 906, Name = "On Your Knees!", Profession = Profession.Warrior };
+        public static Skill OnYourKnees { get; } = new() { Id = 906, Name = "\"On Your Knees!\"", Profession = Profession.Warrior };
         public static Skill YoureAllAlone { get; } = new() { Id = 1412, Name = "\"You're All Alone!\"", Profession = Profession.Warrior };
         public static Skill FrenziedDefense { get; } = new() { Id = 1700, Name = "Frenzied Defense", Profession = Profession.Warrior };
         public static Skill Grapple { get; } = new() { Id = 2011, Name = "Grapple", Profession = Profession.Warrior };
@@ -702,7 +702,7 @@ namespace Daybreak.Models.Builds
         public static Skill Echo { get; } = new() { Id = 74, Name = "Echo", Profession = Profession.Mesmer };
         public static Skill ArcaneEcho { get; } = new() { Id = 75, Name = "Arcane Echo", Profession = Profession.Mesmer };
         public static Skill Epidemic { get; } = new() { Id = 78, Name = "Epidemic", Profession = Profession.Mesmer };
-        public static Skill LyssasBalance { get; } = new() { Id = 877, Name = "Lyssa's Balance, Profession = Profession.Mesmer" };
+        public static Skill LyssasBalance { get; } = new() { Id = 877, Name = "Lyssa's Balance", Profession = Profession.Mesmer };
         public static Skill SignetofDisenchantment { get; } = new() { Id = 882, Name = "Signet of Disenchantment", Profession = Profession.Mesmer };
         public static Skill ShatterStorm { get; } = new() { Id = 933, Name = "Shatter Storm", Profession = Profession.Mesmer };
         public static Skill ExpelHexes { get; } = new() { Id = 954, Name = "Expel Hexes", Profession = Profession.Mesmer };
@@ -1053,7 +1053,7 @@ namespace Daybreak.Models.Builds
         public static Skill FeastofSouls { get; } = new() { Id = 980, Name = "Feast of Souls", Profession = Profession.Ritualist };
         public static Skill RitualLord { get; } = new() { Id = 1217, Name = "Ritual Lord", Profession = Profession.Ritualist };
         public static Skill AttunedWasSongkai { get; } = new() { Id = 1220, Name = "Attuned Was Songkai", Profession = Profession.Ritualist };
-        public static Skill AnguishedWasLingwah { get; } = new() { Id = 1223, Name = "Anguished Was Lingwah, Profession = Profession.Ritualist" };
+        public static Skill AnguishedWasLingwah { get; } = new() { Id = 1223, Name = "Anguished Was Lingwah", Profession = Profession.Ritualist };
         public static Skill ExplosiveGrowth { get; } = new() { Id = 1229, Name = "Explosive Growth", Profession = Profession.Ritualist };
         public static Skill BoonofCreation { get; } = new() { Id = 1230, Name = "Boon of Creation", Profession = Profession.Ritualist };
         public static Skill SpiritChanneling { get; } = new() { Id = 1231, Name = "Spirit Channeling", Profession = Profession.Ritualist };
@@ -1483,8 +1483,8 @@ namespace Daybreak.Models.Builds
         public static Skill VolfenBlessing { get; } = new() { Id = 2379, Name = "Volfen Blessing", Profession = Profession.None };
         public static Skill TimeWard { get; } = new() { Id = 3422, Name = "Time Ward", Profession = Profession.Mesmer };
         public static Skill SoulTaker { get; } = new() { Id = 3423, Name = "Soul Taker", Profession = Profession.Necromancer };
-        public static Skill OverTheLimit { get; } = new() { Id = 3424, Name = "Over The Limit", Profession = Profession.Elementalist };
-        public static Skill JudgementStrike { get; } = new() { Id = 3425, Name = "Judgement Strike", Profession = Profession.Monk };
+        public static Skill OverTheLimit { get; } = new() { Id = 3424, Name = "Over The Limit", AlternativeName = "Over the Limit", Profession = Profession.Elementalist };
+        public static Skill JudgementStrike { get; } = new() { Id = 3425, Name = "Judgement Strike", AlternativeName = "Judgment Strike", Profession = Profession.Monk };
         public static Skill SevenWeaponsStance { get; } = new() { Id = 3426, Name = "Seven Weapons Stance", Profession = Profession.Warrior };
         public static Skill Togetherasone { get; } = new() { Id = 3427, Name = "\"Together as one!\"", Profession = Profession.Ranger };
         public static Skill ShadowTheft { get; } = new() { Id = 3428, Name = "Shadow Theft", Profession = Profession.Assassin };
@@ -3022,6 +3022,7 @@ namespace Daybreak.Models.Builds
         public Profession Profession { get; private set; }
         public string Name { get; private set; }
         public int Id { get; private set; }
+        public string AlternativeName { get; private set; }
         private Skill()
         {
         }

Daybreak/Models/Github/GithubRefTag.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace Daybreak.Models.Github
+{
+    public sealed class GithubRefTag
+    {
+        [JsonProperty("ref")]
+        public string Ref;
+        [JsonProperty("node_id")]
+        public string NodeId;
+        [JsonProperty("url")]
+        public string Url;
+    }
+}

Daybreak/Models/IconPayload.cs

@@ -0,0 +1,8 @@
+namespace Daybreak.Models
+{
+    public sealed class IconPayload
+    {
+        public string SkillUrl { get; set; }
+        public string SkillImage { get; set; }
+    }
+}

Daybreak/Models/IconRequest.cs

@@ -0,0 +1,11 @@
+using Daybreak.Models.Builds;
+
+namespace Daybreak.Models
+{
+    public sealed class IconRequest
+    {
+        public Skill Skill { get; set; }
+        public string IconBase64 { get; set; }
+        public bool Finished { get; set; }
+    }
+}

Daybreak/Models/KeyMacro.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Windows.Forms;
+
+namespace Daybreak.Models
+{
+    public sealed class KeyMacro
+    {
+        public List<Keys> Keys { get; set; }
+        public Keys TargetKey { get; set; }
+    }
+}

Daybreak/Models/KeyboardHookEventArgs.cs

@@ -0,0 +1,17 @@
+namespace Daybreak.Models
+{
+    public sealed class KeyboardHookEventArgs
+    {
+        public bool Handled { get; set; }
+        public KeyboardState KeyboardState { get; }
+        public KeyboardInput KeyboardInput { get; }
+
+        public KeyboardHookEventArgs(
+            KeyboardState keyboardState,
+            KeyboardInput keyboardInput)
+        {
+            this.KeyboardState = keyboardState;
+            this.KeyboardInput = keyboardInput;
+        }
+    }
+}

Daybreak/Models/KeyboardInput.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Daybreak.Models
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct KeyboardInput
+    {
+        /// <summary>
+        /// A virtual-key code. The code must be a value in the range 1 to 254.
+        /// </summary>
+        public int VirtualCode;
+
+        // EDT: added a conversion from VirtualCode to Keys.
+        /// <summary>
+        /// The VirtualCode converted to typeof(Keys) for higher usability.
+        /// </summary>
+        public Keys Key { get { return (Keys)VirtualCode; } }
+
+        /// <summary>
+        /// A hardware scan code for the key. 
+        /// </summary>
+        public int HardwareScanCode;
+
+        /// <summary>
+        /// The extended-key flag, event-injected Flags, context code, and transition-state flag. This member is specified as follows. An application can use the following values to test the keystroke Flags. Testing LLKHF_INJECTED (bit 4) will tell you whether the event was injected. If it was, then testing LLKHF_LOWER_IL_INJECTED (bit 1) will tell you whether or not the event was injected from a process running at lower integrity level.
+        /// </summary>
+        public int Flags;
+
+        /// <summary>
+        /// The time stamp stamp for this message, equivalent to what GetMessageTime would return for this message.
+        /// </summary>
+        public int TimeStamp;
+
+        /// <summary>
+        /// Additional information associated with the message. 
+        /// </summary>
+        public IntPtr AdditionalInformation;
+    }
+}

Daybreak/Models/KeyboardState.cs

@@ -0,0 +1,10 @@
+namespace Daybreak.Models
+{
+    public enum KeyboardState
+    {
+        KeyDown = 0x0100,
+        KeyUp = 0x0101,
+        SysKeyDown = 0x0104,
+        SysKeyUp = 0x0105
+    }
+}

Daybreak/Models/Log.cs

@@ -1,12 +1,15 @@
-using System;
+using Microsoft.Extensions.Logging;
+using System;
 
 namespace Daybreak.Models
 {
-    public class Log
+    public sealed class Log
     {
-        public LogLevel LogLevel { get; set; }
         public string Message { get; set; }
-        public string StackTrace { get; set; }
-        public DateTime Timestamp { 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; }
     }
 }

Daybreak/Models/LogLevel.cs

@@ -1,10 +0,0 @@
-namespace Daybreak.Models
-{
-    public enum LogLevel
-    {
-        Information,
-        Warning,
-        Error,
-        Critical
-    }
-}

Daybreak/Models/Progress/IconDownloadStatus.cs

@@ -0,0 +1,78 @@
+using System.ComponentModel;
+
+namespace Daybreak.Models.Progress
+{
+    public sealed class IconDownloadStatus : INotifyPropertyChanged
+    {
+        public static readonly IconDownloadStep StartingStep = new StartingIconDownloadStep();
+        public static readonly IconDownloadStep Finished = new FinishedIconDownloadStep();
+        public static readonly IconDownloadStep BrowserNotSupported = new NotSupportedIconDownloadStep();
+        public static IconDownloadStep Checking(string iconName, double progress) => new CheckingIconDownloadStep(iconName, progress);
+        public static IconDownloadStep Downloading(string iconName, double progress) => new DownloadingIconDownloadStep(iconName, progress);
+        public static IconDownloadStep Stopped(double progress) => new StoppedIconDownloadStep(progress);
+
+        private IconDownloadStep currentStep = StartingStep;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public IconDownloadStep CurrentStep
+        {
+            get => currentStep;
+            set
+            {
+                currentStep = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentStep)));
+            }
+        }
+
+        public abstract class IconDownloadStep : LoadStatus
+        {
+            public IconDownloadStep(string name, double progress) : base(name)
+            {
+                this.Progress = progress;
+            }
+        }
+
+        public class StoppedIconDownloadStep : IconDownloadStep
+        {
+            public StoppedIconDownloadStep(double progress) : base("Download stopped", progress)
+            {
+            }
+        }
+
+        public class DownloadingIconDownloadStep : IconDownloadStep
+        {
+            public DownloadingIconDownloadStep(string skillName, double progress) : base($"Downloading [{skillName}] icon", progress)
+            {
+            }
+        }
+
+        public class CheckingIconDownloadStep : IconDownloadStep
+        {
+            public CheckingIconDownloadStep(string skillName, double progress) : base($"Checking [{skillName}] icon", progress)
+            {
+            }
+        }
+
+        public class NotSupportedIconDownloadStep : IconDownloadStep
+        {
+            public NotSupportedIconDownloadStep() : base("Cannot download icons. The WebView2 browser is not supported", 0d)
+            {
+            }
+        }
+
+        public class FinishedIconDownloadStep : IconDownloadStep
+        {
+            public FinishedIconDownloadStep() : base("Download finished", 100d)
+            {
+            }
+        }
+
+        public class StartingIconDownloadStep : IconDownloadStep
+        {
+            public StartingIconDownloadStep() : base("Download starting", 0d)
+            {
+            }
+        }
+    }
+}

Daybreak/Models/Progress/LoadStatus.cs

@@ -0,0 +1,12 @@
+namespace Daybreak.Models.Progress
+{
+    public abstract class LoadStatus
+    {
+        public string Description { get; set; }
+        public double Progress { get; set; }
+        public LoadStatus(string description)
+        {
+            this.Description = description;
+        }
+    }
+}

Daybreak/Models/Progress/UpdateStatus.cs

@@ -1,13 +1,15 @@
 using System.ComponentModel;
 
-namespace Daybreak.Models
+namespace Daybreak.Models.Progress
 {
     public sealed class UpdateStatus : INotifyPropertyChanged
     {
         public static readonly UpdateStep StartingStep = new("Starting");
+        public static readonly UpdateStep InitializingDownload = new("Initializing download");
         public static readonly UpdateStep CheckingLatestVersion = new("Checking latest version");
         public static UpdateStep Downloading(double progress) => new DownloadUpdateStep("Downloading", progress);
-        public static readonly UpdateStep DownloadFinished = new("Download finished. Application will restart in order to apply the update.");
+        public static readonly UpdateStep DownloadFinished = new("Download finished. Application will restart in order to apply the update");
+        public static readonly UpdateStep FailedDownload = new("Update failed. Please check logs for details");
 
         private UpdateStep currentStep = StartingStep;
 
@@ -15,30 +17,26 @@ namespace Daybreak.Models
 
         public UpdateStep CurrentStep
         {
-            get => this.currentStep;
+            get => currentStep;
             set
             {
-                this.currentStep = value;
-                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentStep)));
+                currentStep = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentStep)));
             }
         }
 
-        public class UpdateStep
+        public class UpdateStep : LoadStatus
         {
-            public string Name { get; }
-            internal UpdateStep(string name)
+            public UpdateStep(string name) : base(name)
             {
-                this.Name = name;
             }
         }
         public class DownloadUpdateStep : UpdateStep
         {
             internal DownloadUpdateStep(string name, double progress) : base(name)
             {
-                this.Progress = progress;
+                Progress = progress;
             }
-
-            public double Progress { get; }
         }
     }
 }

Daybreak/Models/ScopeMetadata.cs

@@ -0,0 +1,14 @@
+using Microsoft.CorrelationVector;
+
+namespace Daybreak.Models
+{
+    public class ScopeMetadata
+    {
+        public CorrelationVector CorrelationVector { get; set; }
+
+        public ScopeMetadata(CorrelationVector correlationVector)
+        {
+            this.CorrelationVector = correlationVector;
+        }
+    }
+}

Daybreak/Models/SecureString.cs

@@ -9,49 +9,45 @@ namespace Daybreak.Models
     [Serializable]
     public sealed class SecureString
     {
-        public static SecureString Empty { get => new SecureString(string.Empty); }
+        public static SecureString Empty { get => new(string.Empty); }
 
         private byte[] encryptedBytes;
         private readonly byte[] key;
 
         private byte[] DecryptedValue
         {
-            get => encryptedBytes.DecryptBytes(key);
-            set => encryptedBytes = value.EncryptBytes(key);
+            get => this.encryptedBytes.DecryptBytes(key);
+            set => this.encryptedBytes = value.EncryptBytes(key);
         }
         [JsonProperty("value")]
         public string Value
         {
             get
             {
-                return encryptedBytes.DecryptBytes(key).AsString();
+                return this.encryptedBytes.DecryptBytes(key).AsString();
             }
             set
             {
-                encryptedBytes = value.AsBytes().EncryptBytes(key);
+                this.encryptedBytes = value.AsBytes().EncryptBytes(key);
             }
         }
         private SecureString(byte[] value)
         {
-            key = new byte[32];
-            using (var crypto = new RNGCryptoServiceProvider())
-            {
-                crypto.GetBytes(key);
-            }
+            this.key = new byte[32];
+            using var crypto = RandomNumberGenerator.Create();
+            crypto.GetBytes(key);
             this.DecryptedValue = value;
         }
         public SecureString(string value)
         {
-            key = new byte[32];
-            using (var crypto = new RNGCryptoServiceProvider())
-            {
-                crypto.GetBytes(key);
-            }
+            this.key = new byte[32];
+            using var crypto = RandomNumberGenerator.Create();
+            crypto.GetBytes(key);
             this.Value = value;
         }
 
         public static implicit operator string(SecureString ss) => ss is null ? string.Empty : ss.Value;
-        public static implicit operator SecureString(string s) => new SecureString(s);
+        public static implicit operator SecureString(string s) => new(s);
         public static SecureString operator +(SecureString ss1, SecureString ss2)
         {
             if (ss1 is null) throw new ArgumentNullException(nameof(ss1));
@@ -123,12 +119,12 @@ namespace Daybreak.Models
 
         public override int GetHashCode()
         {
-            return Value.GetHashCode();
+            return this.Value.GetHashCode();
         }
 
         public override string ToString()
         {
-            return Value;
+            return this.Value;
         }
     }
 }

Daybreak/Models/Versioning/Version.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.Extensions;
+using System.Linq;
+
+namespace Daybreak.Models.Versioning
+{
+    public sealed class Version
+    {
+        private List<VersionToken> parts = new();
+
+        public bool HasPrefix { get; private set; }
+        public IEnumerable<VersionToken> VersionTokens { get => this.parts; }
+        public string VersionString { get => this.ToString(); }
+
+        private Version()
+        {
+        }
+
+        public Version(string version)
+        {
+            if (TryParseParts(version, out var parts, out var hasPrefix) is false)
+            {
+                throw new ArgumentException($"Provided argument is not valid: {version}");
+            }
+
+            this.parts = parts;
+            this.HasPrefix = hasPrefix;
+        }
+
+        public override string ToString()
+        {
+            var version = string.Join('.', parts.OfType<VersionNumberToken>());
+            if (parts.Last() is VersionStringToken)
+            {
+                version += "-" + parts.Last();
+            }
+
+            if (this.HasPrefix)
+            {
+                version = 'v' + version;
+            }
+
+            return version;
+        }
+
+        public static Version Parse(string version)
+        {
+            if (TryParse(version, out var parsedVersion) is false)
+            {
+                throw new InvalidOperationException($"Unable to parse version: {version}");
+            }
+
+            return parsedVersion;
+        }
+
+        public static bool TryParse(string version, out Version parsedVersion)
+        {
+            if (TryParseParts(version, out var parts, out var hasPrefix) is false)
+            {
+                parsedVersion = null;
+                return false;
+            }
+
+            for (int i = parts.Count - 1; i >= 1; i--)
+            {
+                if (parts[i] is VersionNumberToken && parts[i].ToString() == "0")
+                {
+                    parts.RemoveAt(i);
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            parsedVersion = new Version
+            {
+                parts = parts,
+                HasPrefix = hasPrefix
+            };
+            return true;
+        }
+
+        private static bool TryParseParts(string version, out List<VersionToken> parts, out bool hasPrefix)
+        {
+            hasPrefix = false;
+            parts = null;
+            if (version.IsNullOrWhiteSpace())
+            {
+                return false;
+            }
+
+            if (version.StartsWith('.') || version.EndsWith('.'))
+            {
+                return false;
+            }
+
+            var tokens = version.Trim().Split('.');
+            if (tokens.Length == 0)
+            {
+                return false;
+            }
+
+            if (tokens[0].StartsWith('v'))
+            {
+                hasPrefix = true;
+                tokens[0] = tokens[0][1..];
+            }
+
+            parts = new List<VersionToken>();
+            for(int i = 0; i < tokens.Length - 1; i++)
+            {
+                var token = tokens[i];
+                if (token.IsNullOrWhiteSpace() || token.All(c => char.IsDigit(c)) is false)
+                {
+                    return false;
+                }
+
+                parts.Add(VersionToken.Parse(token));
+            }
+
+            var lastToken = tokens[^1];
+            if (lastToken.Contains('-'))
+            {
+                var lastTokenParts = lastToken.Split('-');
+                if (lastTokenParts.Length > 2 || lastTokenParts.Length < 2)
+                {
+                    return false;
+                }
+
+                if (lastTokenParts[0].IsNullOrWhiteSpace() || lastTokenParts[0].All(c => char.IsDigit(c)) is false)
+                {
+                    return false;
+                }
+
+                parts.Add(VersionToken.Parse(lastTokenParts[0]));
+                if (lastTokenParts[1].IsNullOrWhiteSpace() || lastTokenParts[1].All(c => char.IsLetter(c)) is false)
+                {
+                    return false;
+                }
+
+                parts.Add(VersionToken.Parse(lastTokenParts[1]));
+            }
+            else
+            {
+                if (lastToken.IsNullOrWhiteSpace() || lastToken.Any(c => char.IsDigit(c) is false))
+                {
+                    return false;
+                }
+
+                parts.Add(VersionToken.Parse(lastToken));
+            }
+
+            return true;
+        }
+    }
+}

Daybreak/Models/Versioning/VersionNumberToken.cs

@@ -0,0 +1,16 @@
+namespace Daybreak.Models.Versioning
+{
+    public sealed class VersionNumberToken : VersionToken
+    {
+        public int Number { get; }
+        internal VersionNumberToken(int number)
+        {
+            this.Number = number;
+        }
+
+        protected override string Stringify()
+        {
+            return this.Number.ToString();
+        }
+    }
+}

Daybreak/Models/Versioning/VersionStringToken.cs

@@ -0,0 +1,16 @@
+namespace Daybreak.Models.Versioning
+{
+    public sealed class VersionStringToken : VersionToken
+    {
+        public string Token { get; }
+        internal VersionStringToken(string token)
+        {
+            this.Token = token;
+        }
+
+        protected override string Stringify()
+        {
+            return this.Token;
+        }
+    }
+}

Daybreak/Models/Versioning/VersionToken.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+
+namespace Daybreak.Models.Versioning
+{
+    public abstract class VersionToken
+    {
+        public static VersionToken Parse(string token)
+        {
+            if (token.All(c => char.IsDigit(c)))
+            {
+                var number = int.Parse(token);
+                return new VersionNumberToken(number);
+            }
+
+            if (token.All(c => char.IsLetter(c)))
+            {
+                return new VersionStringToken(token);
+            }
+
+            throw new ArgumentException($"Failed to parse version token {token}");
+        }
+
+        protected abstract string Stringify();
+
+        public override string ToString()
+        {
+            return this.Stringify();
+        }
+    }
+}

Daybreak/Services/ApplicationLauncher/ApplicationLauncher.cs

@@ -1,15 +1,15 @@
-using Daybreak.Exceptions;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Exceptions;
 using Daybreak.Services.Credentials;
-using Daybreak.Services.Logging;
 using Daybreak.Services.Mutex;
 using Daybreak.Services.Privilege;
-using Daybreak.Utils;
 using Daybreak.Views;
+using Microsoft.Extensions.Logging;
 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;
@@ -30,10 +30,10 @@ 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 logger;
+        private readonly ILogger<ApplicationLauncher> logger;
         private readonly IPrivilegeManager privilegeManager;
 
         public bool IsTexmodRunning => TexModProcessDetected();
@@ -41,22 +41,22 @@ namespace Daybreak.Services.ApplicationLauncher
         public bool IsToolboxRunning => GuildwarsToolboxProcessDetected();
 
         public ApplicationLauncher(
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             ICredentialManager credentialManager,
             IMutexHandler mutexHandler,
-            ILogger logger,
+            ILogger<ApplicationLauncher> logger,
             IPrivilegeManager privilegeManager)
         {
             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) =>
@@ -69,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: () =>
                 {
@@ -85,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)
                 {
@@ -103,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)
                 {
@@ -146,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");
@@ -170,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");
@@ -179,10 +179,10 @@ namespace Daybreak.Services.ApplicationLauncher
                 StartInfo = new ProcessStartInfo
                 {
                     Arguments = string.Join(" ", args),
-                    UserName = identity
+                    FileName = executable.Path
                 }
             };
-            if (Process.Start(executable.Path, args) is null)
+            if (process.Start() is false)
             {
                 throw new InvalidOperationException($"Unable to launch {executable}");
             }
@@ -190,7 +190,7 @@ namespace Daybreak.Services.ApplicationLauncher
             var retries = 0;
             while (true)
             {
-                await Task.Delay(1000);
+                await Task.Delay(100);
                 retries++;
                 var gwProcess = Process.GetProcessesByName("gw").FirstOrDefault();
                 if (gwProcess is null && retries < MaxRetries)
@@ -202,20 +202,31 @@ namespace Daybreak.Services.ApplicationLauncher
                     throw new InvalidOperationException("Newly launched gw process not detected");
                 }
 
-                if (gwProcess.MainWindowHandle != IntPtr.Zero)
+                if (gwProcess.MainWindowHandle == IntPtr.Zero)
                 {
-                    return true;
+                    continue;
                 }
+
+                int titleLength = NativeMethods.GetWindowTextLength(gwProcess.MainWindowHandle);
+                var titleBuffer = new StringBuilder(titleLength);
+                var readCount = NativeMethods.GetWindowText(gwProcess.MainWindowHandle, titleBuffer, titleLength + 1);
+                var title = titleBuffer.ToString();
+                if (title != "Guild Wars")
+                {
+                    continue;
+                }
+
+                return true;
             }
         }
 
         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;
@@ -243,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");

Daybreak/Services/ApplicationLifetime/ApplicationLifetimeManager.cs

@@ -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();
-            }
-        }
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeManager.cs

@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeManager : IApplicationLifetimeProducer
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeProducer.cs

@@ -1,7 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeProducer
-    {
-        void RegisterService<T>() where T : IApplicationLifetimeService;
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeService.cs

@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeService
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}

Daybreak/Services/Bloogum/BloogumClient.cs

@@ -1,6 +1,5 @@
 using Daybreak.Services.Bloogum.Models;
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Extensions;
 using System.IO;
@@ -12,15 +11,16 @@ namespace Daybreak.Services.Bloogum
     public sealed class BloogumClient : IBloogumClient
     {
         private const string BaseAddress = "http://bloogum.net/guildwars";
-        private readonly HttpClient httpClient;
+        private readonly IHttpClient<BloogumClient> httpClient;
         private readonly ILogger logger;
         private readonly Random random = new();
 
-        public BloogumClient(ILogger logger)
+        public BloogumClient(
+            ILogger<BloogumClient> logger,
+            IHttpClient<BloogumClient> httpClient)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
-
-            this.httpClient = new HttpClient();
+            this.httpClient = httpClient.ThrowIfNull(nameof(httpClient));
         }
 
         public async Task<Optional<Stream>> GetRandomScreenShot()
@@ -53,7 +53,7 @@ namespace Daybreak.Services.Bloogum
             }
             catch(Exception e)
             {
-                this.logger.LogError(e);
+                this.logger.LogError(e.ToString());
                 return Optional.None<Stream>();
             }
         }

Daybreak/Services/Bloogum/Models/Location.cs

@@ -81,13 +81,13 @@ namespace Daybreak.Services.Bloogum.Models
                     new Category("stingraystrand", 15),
                     new Category("fishermenshaven", 4),
                     new Category("riversideprovince", 31),
-                    new Category("sanctumcay", 21)
+                    new Category("sanctumcay", 21),
+                    new Category("majestysrest", 14)
             });
         public static readonly Location MaguumaJungle = new(
             "maguuma",
             new List<Category>
             {
-                    new Category("majestysrest", 14),
                     new Category("druidsoverlook", 1),
                     new Category("sagelands", 27),
                     new Category("thewilds", 19),

Daybreak/Services/BuildTemplates/BuildTemplateManager.cs

@@ -1,7 +1,6 @@
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates.Models;
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Extensions;
@@ -16,10 +15,10 @@ namespace Daybreak.Services.BuildTemplates
         private const string DecodingLookupTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
         private readonly static string BuildsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\Guild Wars\\Templates\\Skills";
 
-        private readonly ILogger logger;
+        private readonly ILogger<BuildTemplateManager> logger;
 
         public BuildTemplateManager(
-            ILogger logger)
+            ILogger<BuildTemplateManager> logger)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
         }
@@ -229,8 +228,10 @@ namespace Daybreak.Services.BuildTemplates
         {
             var curedTemplate = template.Trim();
 
-            var buildMetadata = new BuildMetadata();
-            buildMetadata.Base64Decoded = template.Select(c => DecodingLookupTable.IndexOf(c)).ToList();
+            var buildMetadata = new BuildMetadata
+            {
+                Base64Decoded = template.Select(c => DecodingLookupTable.IndexOf(c)).ToList(),
+            };
             buildMetadata.BinaryDecoded = buildMetadata.Base64Decoded.Select(b => ToBitString(b)).ToList();
 
             var stream = new DecodeCharStream(buildMetadata.BinaryDecoded.ToArray());

Daybreak/Services/Configuration/ConfigurationManager.cs

@@ -1,7 +1,6 @@
 using Daybreak.Configuration;
-using Daybreak.Exceptions;
-using Daybreak.Services.Logging;
 using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Extensions;
 using System.IO;
@@ -13,9 +12,11 @@ namespace Daybreak.Services.Configuration
         private const string ConfigName = "Daybreak.config.json";
 
         private ApplicationConfiguration applicationConfiguration;
-        private readonly ILogger logger;
+        private readonly ILogger<ConfigurationManager> logger;
 
-        public ConfigurationManager(ILogger logger)
+        public event EventHandler ConfigurationChanged;
+
+        public ConfigurationManager(ILogger<ConfigurationManager> logger)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
             try
@@ -25,7 +26,7 @@ namespace Daybreak.Services.Configuration
             }
             catch(Exception e)
             {
-                this.logger.LogWarning($"No configuration detected. Loading default configuration. Details: {e}");
+                this.logger.LogWarning(e, $"Failed to load configuration. Falling back to default configuration");
                 this.applicationConfiguration = new ApplicationConfiguration();
             }
         }
@@ -39,6 +40,7 @@ namespace Daybreak.Services.Configuration
         {
             File.WriteAllText(ConfigName, applicationConfiguration.Serialize());
             this.applicationConfiguration = applicationConfiguration;
+            this.ConfigurationChanged?.Invoke(this, new EventArgs());
         }
     }
 }

Daybreak/Services/Configuration/IConfigurationManager.cs

@@ -1,9 +1,11 @@
 using Daybreak.Configuration;
+using System;
 
 namespace Daybreak.Services.Configuration
 {
     public interface IConfigurationManager
     {
+        event EventHandler ConfigurationChanged;
         ApplicationConfiguration GetConfiguration();
         void SaveConfiguration(ApplicationConfiguration applicationConfiguration);
     }

Daybreak/Services/Credentials/CredentialManager.cs

@@ -1,9 +1,9 @@
-using Daybreak.Models;
-using Daybreak.Services.Configuration;
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
+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,14 +15,14 @@ namespace Daybreak.Services.Credentials
     public sealed class CredentialManager : ICredentialManager
     {
         private static readonly byte[] Entropy = Convert.FromBase64String("R3VpbGR3YXJz");
-        private readonly ILogger logger;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILogger<CredentialManager> logger;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
 
         public CredentialManager(
-            ILogger logger,
-            IConfigurationManager configurationManager)
+            ILogger<CredentialManager> logger,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions)
         {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.logger = logger.ThrowIfNull(nameof(logger));
         }
 
@@ -54,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");
@@ -63,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();
             });
         }
@@ -74,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();
             });   
         }
 

Daybreak/Services/IconRetrieve/IIconBrowser.cs

@@ -0,0 +1,17 @@
+using Daybreak.Controls;
+using Daybreak.Models;
+using Microsoft.Web.WebView2.Wpf;
+using System.Threading;
+
+namespace Daybreak.Services.IconRetrieve
+{
+    public interface IIconBrowser
+    {
+        void InitializeWebView(WebView2 webView2, CancellationToken cancellationToken);
+        /// <summary>
+        /// Queue an icon request. The browser will attempt to download the icon. Monitor the <see cref="IconRequest.Finished"/> to be notified when the request has been served.
+        /// </summary>
+        /// <param name="iconRequest">Request model.</param>
+        void QueueIconRequest(IconRequest iconRequest);
+    }
+}

Daybreak/Services/IconRetrieve/IIconCache.cs

@@ -1,12 +1,12 @@
 using Daybreak.Models.Builds;
+using System;
 using System.Extensions;
-using System.IO;
 using System.Threading.Tasks;
 
 namespace Daybreak.Services.IconRetrieve
 {
-    public interface IIconRetriever
+    public interface IIconCache
     {
-        Task<Optional<Stream>> GetIcon(Skill skill);
+        Task<Optional<Uri>> GetIconUri(Skill skill);
     }
 }

Daybreak/Services/IconRetrieve/IIconDownloader.cs

@@ -0,0 +1,16 @@
+using Daybreak.Controls;
+using Daybreak.Models.Progress;
+using Microsoft.Web.WebView2.Wpf;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.IconRetrieve
+{
+    public interface IIconDownloader
+    {
+        void SetBrowser(WebView2 chromiumBrowserWrapper);
+
+        bool DownloadComplete { get; }
+        Task<IconDownloadStatus> StartIconDownload();
+        void CancelIconDownload();
+    }
+}

Daybreak/Services/IconRetrieve/IconBrowser.cs

@@ -0,0 +1,178 @@
+using Daybreak.Controls;
+using Daybreak.Models;
+using Daybreak.Models.Builds;
+using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
+using Microsoft.Web.WebView2.Core;
+using Microsoft.Web.WebView2.Wpf;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Concurrent;
+using System.Core.Extensions;
+using System.Extensions;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace Daybreak.Services.IconRetrieve
+{
+    public sealed class IconBrowser : IIconBrowser
+    {
+        // Sometimes due to browser issues, retrieved base64 is just a blank jpeg. This is the base64 of the image.
+        private const string FaultyBase64 = "/9j/4AAQSkZJRgABAQAAAQABAAD/4gIoSUNDX1BST0ZJTEUAAQEAAAIYAAAAAAQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAAHRyWFlaAAABZAAAABRnWFlaAAABeAAAABRiWFlaAAABjAAAABRyVFJDAAABoAAAAChnVFJDAAABoAAAAChiVFJDAAABoAAAACh3dHB0AAAByAAAABRjcHJ0AAAB3AAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAFgAAAAcAHMAUgBHAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z3BhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABYWVogAAAAAAAA9tYAAQAAAADTLW1sdWMAAAAAAAAAAQAAAAxlblVTAAAAIAAAABwARwBvAG8AZwBsAGUAIABJAG4AYwAuACAAMgAwADEANv/bAEMAAwICAgICAwICAgMDAwMEBgQEBAQECAYGBQYJCAoKCQgJCQoMDwwKCw4LCQkNEQ0ODxAQERAKDBITEhATDxAQEP/bAEMBAwMDBAMECAQECBALCQsQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEP/AABEIAEAAQAMBIgACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAACf/EABQQAQAAAAAAAAAAAAAAAAAAAAD/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AlUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//2Q==";
+        private const string LargeFaultyBase64 = "/9j/4AAQSkZJRgABAQAAAQABAAD/4gIoSUNDX1BST0ZJTEUAAQEAAAIYAAAAAAQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlkZXNjAAAA8AAAAHRyWFlaAAABZAAAABRnWFlaAAABeAAAABRiWFlaAAABjAAAABRyVFJDAAABoAAAAChnVFJDAAABoAAAAChiVFJDAAABoAAAACh3dHB0AAAByAAAABRjcHJ0AAAB3AAAADxtbHVjAAAAAAAAAAEAAAAMZW5VUwAAAFgAAAAcAHMAUgBHAEIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z3BhcmEAAAAAAAQAAAACZmYAAPKnAAANWQAAE9AAAApbAAAAAAAAAABYWVogAAAAAAAA9tYAAQAAAADTLW1sdWMAAAAAAAAAAQAAAAxlblVTAAAAIAAAABwARwBvAG8AZwBsAGUAIABJAG4AYwAuACAAMgAwADEANv/bAEMAAwICAgICAwICAgMDAwMEBgQEBAQECAYGBQYJCAoKCQgJCQoMDwwKCw4LCQkNEQ0ODxAQERAKDBITEhATDxAQEP/bAEMBAwMDBAMECAQECBALCQsQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEP/AABEIAIAAQAMBIgACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAACf/EABQQAQAAAAAAAAAAAAAAAAAAAAD/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAwDAQACEQMRAD8AlUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//2Q==";
+        private const string BaseUrl = "https://wiki.guildwars.com";
+        private const string QueryUrl = $"wiki/File:{NamePlaceholder}.jpg";
+        private const string NamePlaceholder = "[SKILLNAME]";
+        private const string IconsDirectoryName = "Icons";
+        private const string IconsLocation = $"{IconsDirectoryName}/{NamePlaceholder}.jpg";
+
+        private readonly ConcurrentQueue<IconRequest> iconRequests = new();
+        private readonly ILogger<IconBrowser> logger;
+        private WebView2 browserWrapper;
+        private CancellationToken cancellationToken;
+
+        public IconBrowser(
+            ILogger<IconBrowser> logger)
+        {
+            this.logger = logger.ThrowIfNull();
+        }
+
+        public void InitializeWebView(WebView2 webView2, CancellationToken cancellationToken)
+        {
+            this.browserWrapper = webView2.ThrowIfNull();
+            this.cancellationToken = cancellationToken;
+            Task.Run(this.PeriodicallyServeRequests, cancellationToken);
+        }
+
+        public void QueueIconRequest(IconRequest iconRequest)
+        {
+            this.iconRequests.Enqueue(iconRequest);
+        }
+
+        private async Task PeriodicallyServeRequests()
+        {
+            while(this.cancellationToken.IsCancellationRequested is false)
+            {
+                await Application.Current.Dispatcher.InvokeAsync(async () =>
+                {
+                    await this.ServeRequest();
+                });
+            }
+        }
+
+        private async Task ServeRequest()
+        {
+            if (this.cancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+
+            if (this.iconRequests.TryDequeue(out var request) is false)
+            {
+                await Task.Delay(1000);
+                return;
+            }
+
+            var logger = this.logger.CreateScopedLogger(nameof(this.PeriodicallyServeRequests), request.Skill?.Name);
+            logger.LogInformation($"Retrieving icon");
+            while (this.browserWrapper is null)
+            {
+                if (this.cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                logger.LogInformation($"Browser is not yet initialized. Waiting");
+                await Task.Delay(1000);
+            }
+
+            try
+            {
+                await this.browserWrapper.EnsureCoreWebView2Async();
+            }
+            catch(Exception e)
+            {
+
+            }
+
+            var curedSkillName = request.Skill.AlternativeName.IsNullOrWhiteSpace() ?
+                request.Skill.Name.Replace(" ", "_") :
+                request.Skill.AlternativeName.Replace(" ", "_");
+            var skillIconUrl = $"{BaseUrl}/{QueryUrl.Replace(NamePlaceholder, curedSkillName)}";
+            logger.LogInformation($"Looking for icon at {skillIconUrl}");
+
+            this.browserWrapper.CoreWebView2.Navigate(skillIconUrl);
+
+            for (var i = 0; i < 5; i++)
+            {
+                if (this.cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                logger.LogInformation("Executing extraction script");
+                var responseTask = await Application.Current.Dispatcher.InvokeAsync(async () =>
+                {
+                    return await this.browserWrapper.ExecuteScriptAsync(Scripts.GetHrefFromSkillPage);
+                });
+                var response = await responseTask;
+                logger.LogInformation("Parsing response");
+                var iconPayload = JsonConvert.DeserializeObject<IconPayload>(response);
+                if (iconPayload is null)
+                {
+                    logger.LogInformation("Bad response");
+                    await Task.Delay(1000);
+                    continue;
+                }
+
+                if (iconPayload.SkillUrl != skillIconUrl.Replace("\"", "%22"))
+                {
+                    logger.LogInformation("Retrieved icon doesn't match");
+                    await Task.Delay(1000);
+                    continue;
+                }
+
+                var potentialBase64 = iconPayload.SkillImage.Split(',').Skip(1).FirstOrDefault();
+                if (potentialBase64 == FaultyBase64 ||
+                    potentialBase64 == LargeFaultyBase64)
+                {
+                    logger.LogInformation("Faulty base64 retrieved");
+                    await Task.Delay(1000);
+                    continue;
+                }
+
+                byte[] bytes;
+                try
+                {
+                    bytes = Convert.FromBase64String(potentialBase64);
+                }
+                catch
+                {
+                    logger.LogError("Failed to parse base64");
+                    await Task.Delay(1000);
+                    continue;
+                }
+
+                await SaveIconLocally(request.Skill, bytes);
+                request.IconBase64 = potentialBase64;
+                request.Finished = true;
+                break;
+            }
+
+            logger.LogError($"Failed to retrieve icon");
+            request.Finished = true;
+        }
+
+        private static async Task<string> SaveIconLocally(Skill skill, byte[] data)
+        {
+            var curedSkillName = skill.Name
+                .Replace(" ", "_")
+                .Replace("\"", "");
+            await File.WriteAllBytesAsync(IconsLocation.Replace(NamePlaceholder, curedSkillName), data);
+            return curedSkillName;
+        }
+    }
+}

Daybreak/Services/IconRetrieve/IconCache.cs

@@ -0,0 +1,56 @@
+using Daybreak.Models.Builds;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Core.Extensions;
+using System.Extensions;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.IconRetrieve
+{
+    public sealed class IconCache : IIconCache
+    {
+        private const string NamePlaceholder = "[SKILLNAME]";
+        private const string IconsDirectoryName = "Icons";
+        private const string IconsLocation = $"{IconsDirectoryName}/{NamePlaceholder}.jpg";
+
+        private readonly ILogger<IconCache> logger;
+
+        public IconCache(
+            ILogger<IconCache> logger)
+        {
+            this.logger = logger.ThrowIfNull();
+            if (Directory.Exists(IconsDirectoryName) is false)
+            {
+                Directory.CreateDirectory(IconsDirectoryName);
+            }
+        }
+
+        public Task<Optional<Uri>> GetIconUri(Skill skill)
+        {
+            var maybeIconUri = this.GetLocalIcon(skill);
+            if (maybeIconUri.ExtractValue() is Uri uri)
+            {
+                return Task.FromResult(Optional.FromValue(uri));
+            }
+
+            return Task.FromResult(Optional.None<Uri>());
+        }
+
+        private Optional<Uri> GetLocalIcon(Skill skill)
+        {
+            var curedSkillName = skill.Name
+                .Replace(" ", "_")
+                .Replace("\"", "");
+            this.logger.LogInformation("Checking local icon cache");
+            if (File.Exists(IconsLocation.Replace(NamePlaceholder, curedSkillName)))
+            {
+                this.logger.LogInformation("Local icon cache found. Retrieving icon");
+                return new Uri(AppDomain.CurrentDomain.BaseDirectory + "/" + IconsLocation.Replace(NamePlaceholder, curedSkillName), UriKind.Absolute);
+            }
+
+            this.logger.LogWarning("No local icon cache found");
+            return Optional.None<Uri>();
+        }
+    }
+}

Daybreak/Services/IconRetrieve/IconDownloader.cs

@@ -0,0 +1,239 @@
+using Daybreak.Configuration;
+using Daybreak.Controls;
+using Daybreak.Models;
+using Daybreak.Models.Builds;
+using Daybreak.Models.Progress;
+using Daybreak.Services.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Web.WebView2.Core;
+using Microsoft.Web.WebView2.Wpf;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Core.Extensions;
+using System.Extensions;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Extensions.Services;
+
+namespace Daybreak.Services.IconRetrieve
+{
+    public sealed class IconDownloader : IIconDownloader, IApplicationLifetimeService
+    {
+        private readonly IIconBrowser iconBrowser;
+        private readonly IIconCache iconCache;
+        private readonly IConfigurationManager configurationManager;
+        private readonly ILogger<IconDownloader> logger;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
+        private readonly ILogger<ChromiumBrowserWrapper> browserLogger;
+        private WebView2 browserWrapper;
+        private CancellationTokenSource cancellationTokenSource;
+        private IconDownloadStatus iconDownloadStatus;
+
+        public bool DownloadComplete { get; private set; }
+        public bool Downloading => this.cancellationTokenSource is not null;
+
+        public IconDownloader(
+            IIconBrowser iconBrowser,
+            IIconCache iconCache,
+            IConfigurationManager configurationManager,
+            ILogger<IconDownloader> logger,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
+            ILogger<ChromiumBrowserWrapper> browserLogger)
+        {
+            this.iconBrowser = iconBrowser.ThrowIfNull();
+            this.iconCache = iconCache.ThrowIfNull();
+            this.configurationManager = configurationManager.ThrowIfNull();
+            this.logger = logger.ThrowIfNull();
+            this.liveOptions = liveOptions.ThrowIfNull();
+            this.browserLogger = browserLogger.ThrowIfNull();
+            this.HookIntoConfigurationChanges();
+        }
+
+        public void SetBrowser(WebView2 chromiumBrowserWrapper)
+        {
+            if (this.browserWrapper is not null)
+            {
+                throw new InvalidOperationException("Browser is already set");
+            }
+
+            this.browserWrapper = chromiumBrowserWrapper;
+        }
+
+        public async Task<IconDownloadStatus> StartIconDownload()
+        {
+            while(this.browserWrapper is null)
+            {
+                await Task.Delay(100);
+            }
+
+            this.logger.LogInformation("Starting download");
+            if (this.Downloading)
+            {
+                this.logger.LogInformation("Download already running");
+                return this.iconDownloadStatus;
+            }
+
+            this.cancellationTokenSource = new();
+            this.iconDownloadStatus = new IconDownloadStatus();
+            Task.Run(this.DownloadIcons);
+            return this.iconDownloadStatus;
+        }
+
+        public void CancelIconDownload()
+        {
+            this.cancellationTokenSource?.Cancel();
+            this.cancellationTokenSource?.Dispose();
+            this.cancellationTokenSource = null;
+        }
+
+        private async Task DownloadIcons()
+        {
+            this.logger.LogInformation("Beginning icon download");
+            if (await TestBrowserSupported() is false)
+            {
+                this.logger.LogError("Browser not supported. Icon downloading stopped");
+                this.iconDownloadStatus.CurrentStep = IconDownloadStatus.BrowserNotSupported;
+                return;
+            }
+
+            var progressIncrement = 100d / Skill.Skills.Count();
+            var progressValue = 0d;
+            var skillsToDownload = new List<Skill>();
+            foreach(var skill in Skill.Skills.OrderBy(s => s.Name))
+            {
+                if (skill == Skill.NoSkill)
+                {
+                    continue;
+                }
+
+                var logger = this.logger.CreateScopedLogger(nameof(this.DownloadIcons), skill.Name);
+                logger.LogInformation("Verifying if icon exists");
+                this.iconDownloadStatus.CurrentStep = IconDownloadStatus.Checking(skill.Name, progressValue);
+                if ((await this.iconCache.GetIconUri(skill)).ExtractValue() is not null)
+                {
+                    progressValue += progressIncrement;
+                    await Task.Delay(1);
+                    continue;
+                }
+
+                skillsToDownload.Add(skill);
+            }
+
+            if (skillsToDownload.Count == 0)
+            {
+                this.logger.LogInformation("No icons missing. Stopping download");
+                this.iconDownloadStatus.CurrentStep = IconDownloadStatus.Finished;
+                return;
+            }
+
+            this.iconBrowser.InitializeWebView(this.browserWrapper, this.cancellationTokenSource.Token);
+            
+            var incomplete = false;
+            foreach (var skill in skillsToDownload)
+            {
+                if (this.cancellationTokenSource?.IsCancellationRequested is null or true)
+                {
+                    this.iconDownloadStatus.CurrentStep = IconDownloadStatus.Stopped(progressValue);
+                    return;
+                }
+
+                if (skill == Skill.NoSkill)
+                {
+                    progressValue += progressIncrement;
+                    continue;
+                }                
+
+                logger.LogInformation("Downloading icon");
+                this.iconDownloadStatus.CurrentStep = IconDownloadStatus.Downloading(skill.Name, progressValue);
+                var request = new IconRequest { Skill = skill };
+                this.iconBrowser.QueueIconRequest(request);
+
+                while (request.Finished is false)
+                {
+                    await Task.Delay(1000);
+                }
+
+                if (request.IconBase64.IsNullOrWhiteSpace())
+                {
+                    logger.LogWarning("Failed to download icon");
+                    incomplete = true;
+                }
+                else
+                {
+                    logger.LogInformation("Downloaded icon");
+                }
+
+                progressValue += progressIncrement;
+            }
+
+            if (incomplete)
+            {
+                this.logger.LogError("Failed to download all icons. Retrying");
+                await this.DownloadIcons();
+            }
+            else
+            {
+                Application.Current.Dispatcher.Invoke(() =>
+                {
+                    this.browserWrapper.IsEnabled = false;
+                    this.browserWrapper.Dispose();
+                });
+                this.iconDownloadStatus.CurrentStep = IconDownloadStatus.Finished;
+                this.DownloadComplete = true;
+            }
+        }
+
+        private static async Task<bool> TestBrowserSupported()
+        {
+            CoreWebView2Environment coreWebView2Environment;
+            try
+            {
+                var task = await Application.Current.Dispatcher.InvokeAsync(async () =>
+                {
+                    return await CoreWebView2Environment.CreateAsync().ConfigureAwait(true);
+                });
+
+                coreWebView2Environment = await task;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+
+            return coreWebView2Environment is not null;
+        }
+
+        private void HookIntoConfigurationChanges()
+        {
+            this.configurationManager.ConfigurationChanged += async (_, _) =>
+            {
+                var configuration = this.configurationManager.GetConfiguration();
+                if (configuration.ExperimentalFeatures.DownloadIcons)
+                {
+                    await this.StartIconDownload();
+                }
+                else
+                {
+                    this.CancelIconDownload();
+                }
+            };
+        }
+
+        public async void OnStartup()
+        {
+            var configuration = this.configurationManager.GetConfiguration();
+            if (configuration.ExperimentalFeatures.DownloadIcons)
+            {
+                await this.StartIconDownload();
+            }
+        }
+
+        public void OnClosing()
+        {
+            this.cancellationTokenSource?.Cancel();
+        }
+    }
+}

Daybreak/Services/IconRetrieve/IconRetriever.cs

@@ -1,79 +0,0 @@
-using Daybreak.Models.Builds;
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
-using HtmlAgilityPack;
-using System;
-using System.Extensions;
-using System.IO;
-using System.Linq;
-using System.Net.Http;
-using System.Threading.Tasks;
-
-namespace Daybreak.Services.IconRetrieve
-{
-    public sealed class IconRetriever : IIconRetriever
-    {
-        private const string NamePlaceholder = "[SKILLNAME]";
-        private const string BaseUrl = "https://wiki.guildwars.com";
-        private const string QueryUrl = $"wiki/File:{NamePlaceholder}.jpg";
-
-        private readonly HttpClient httpClient = new();
-        private readonly ILogger logger;
-
-        public IconRetriever(
-            ILogger logger)
-        {
-            this.logger = logger.ThrowIfNull(nameof(logger));
-            this.httpClient.BaseAddress = new Uri(BaseUrl);
-        }
-
-        public async Task<Optional<Stream>> GetIcon(Skill skill)
-        {
-            var curedSkillName = skill.Name
-                .Replace(" ", "_");
-            var skillIconUrl = QueryUrl.Replace(NamePlaceholder, curedSkillName);
-            this.logger.LogInformation($"Looking up icon for skill '{skill.Name}' at url {skillIconUrl}");
-            using var response = await this.httpClient.GetAsync(skillIconUrl).ConfigureAwait(false);
-            if (response.IsSuccessStatusCode is false)
-            {
-                this.logger.LogError($"Client returned status code {response.StatusCode}");
-                return Optional.None<Stream>();
-            }
-
-            this.logger.LogInformation("Crawling through response for href to latest icon url");
-            var doc = new HtmlDocument();
-            doc.LoadHtml(await response.Content.ReadAsStringAsync());
-            var url = GetHref(doc);
-            if (url is null)
-            {
-                this.logger.LogError("Failed to find latest icon url");
-                return Optional.None<Stream>();
-            }
-
-            this.logger.LogInformation($"Found latest icon url at {BaseUrl + "/" + url}. Requesting stream");
-            using var iconResponse = await this.httpClient.GetAsync(url);
-            if (response.IsSuccessStatusCode)
-            {
-                this.logger.LogInformation("Retrieved latest icon stream");
-                return new MemoryStream(await iconResponse.Content.ReadAsByteArrayAsync());
-            }
-
-            this.logger.LogError($"Failed to retrieve icon from {BaseUrl + "/" + url}");
-            return Optional.None<Stream>();
-        }
-
-        private static string GetHref(HtmlDocument doc)
-        {
-            foreach (var child in doc.DocumentNode.Descendants("a"))
-            {
-                var targetAttribute = child.Attributes.Where(a => a.Name == "href" && a.Value.Contains("images")).FirstOrDefault();
-                if (targetAttribute is not null)
-                {
-                    return targetAttribute.Value;
-                }
-            }
-
-            return null;
-        }
-    }
-}

Daybreak/Services/KeyboardHook/IKeyboardHookService.cs

@@ -0,0 +1,11 @@
+using Daybreak.Models;
+using System;
+using System.Windows.Extensions.Services;
+
+namespace Daybreak.Services.KeyboardHook
+{
+    public interface IKeyboardHookService : IApplicationLifetimeService
+    {
+        event EventHandler<KeyboardHookEventArgs> KeyboardPressed;
+    }
+}

Daybreak/Services/KeyboardHook/KeyboardHookService.cs

@@ -0,0 +1,116 @@
+using Daybreak.Models;
+using Microsoft.Extensions.Logging;
+using Pepa.Wpf.Utilities;
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Extensions;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.Services.KeyboardHook
+{
+    // Based on https://gist.github.com/Stasonix
+    // https://stackoverflow.com/questions/604410/global-keyboard-capture-in-c-sharp-application
+    public sealed class KeyboardHookService : IKeyboardHookService, IDisposable
+    {
+        private readonly ILogger<KeyboardHookService> logger;
+        private IntPtr windowsHookHandle;
+        private IntPtr user32LibraryHandle;
+        private NativeMethods.HookProc hookProc;
+
+        public event EventHandler<KeyboardHookEventArgs> KeyboardPressed;
+
+        public KeyboardHookService(
+            ILogger<KeyboardHookService> logger)
+        {
+            this.logger = logger.ThrowIfNull(nameof(logger));
+            this.Setup();
+        }
+
+        public void OnStartup()
+        {
+        }
+
+        public void OnClosing()
+        {
+            this.Dispose();
+        }
+
+        private void Setup()
+        {
+            this.windowsHookHandle = IntPtr.Zero;
+            this.hookProc = this.LowLevelKeyboardProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour.
+
+            this.user32LibraryHandle = NativeMethods.LoadLibrary("User32");
+            if (this.user32LibraryHandle == IntPtr.Zero)
+            {
+                int errorCode = Marshal.GetLastWin32Error();
+                this.logger.LogError($"Failed to load library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
+            }
+
+            this.windowsHookHandle = NativeMethods.SetWindowsHookEx(NativeMethods.WH_KEYBOARD_LL, this.hookProc, this.user32LibraryHandle, 0);
+            if (this.windowsHookHandle == IntPtr.Zero)
+            {
+                int errorCode = Marshal.GetLastWin32Error();
+                this.logger.LogError($"Failed to adjust keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
+            }
+        }
+
+        private IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            var handled = false;
+            var wparamTyped = wParam.ToInt32();
+            if (Enum.IsDefined(typeof(KeyboardState), wparamTyped))
+            {
+                var p = Marshal.PtrToStructure(lParam, typeof(KeyboardInput)).Cast<KeyboardInput>();
+                var eventArguments = new KeyboardHookEventArgs(wparamTyped.Cast<KeyboardState>(), p);
+                this.KeyboardPressed?.Invoke(this, eventArguments);
+                handled = eventArguments.Handled;
+            }
+
+            return handled ? (IntPtr)1 : NativeMethods.CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                // because we can unhook only in the same thread, not in garbage collector thread
+                if (this.windowsHookHandle != IntPtr.Zero)
+                {
+                    if (NativeMethods.UnhookWindowsHookEx(this.windowsHookHandle) is false)
+                    {
+                        int errorCode = Marshal.GetLastWin32Error();
+                        this.logger.LogCritical($"Failed to remove keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
+                    }
+
+                    this.windowsHookHandle = IntPtr.Zero;
+                    this.hookProc -= LowLevelKeyboardProc;
+                }
+            }
+
+            if (this.user32LibraryHandle != IntPtr.Zero)
+            {
+                if (NativeMethods.FreeLibrary(this.user32LibraryHandle) is false) // reduces reference to library by 1.
+                {
+                    int errorCode = Marshal.GetLastWin32Error();
+                    this.logger.LogCritical($"Failed to unload library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
+                }
+
+                this.user32LibraryHandle = IntPtr.Zero;
+            }
+        }
+
+        ~KeyboardHookService()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}

Daybreak/Services/KeyboardMacros/IMacroService.cs

@@ -0,0 +1,8 @@
+using System.Windows.Extensions.Services;
+
+namespace Daybreak.Services.KeyboardMacros
+{
+    public interface IMacroService : IApplicationLifetimeService
+    {
+    }
+}

Daybreak/Services/KeyboardMacros/MacroService.cs

@@ -0,0 +1,106 @@
+using Daybreak.Configuration;
+using Daybreak.Models;
+using Daybreak.Services.KeyboardHook;
+using Pepa.Wpf.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Extensions;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Windows.Forms;
+
+namespace Daybreak.Services.KeyboardMacros
+{
+    public sealed class MacroService : IMacroService
+    {
+        private readonly CancellationTokenSource cancellationTokenSource = new();
+        private readonly IKeyboardHookService keyboardHookService;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
+        private readonly HashSet<Keys> KeysDown = new();
+
+        private bool gameActive;
+        private IntPtr gwWindowHwnd;
+
+        public MacroService(
+            IKeyboardHookService keyboardHookService,
+            ILiveOptions<ApplicationConfiguration> liveOptions)
+        {
+            this.keyboardHookService = keyboardHookService.ThrowIfNull(nameof(keyboardHookService));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
+
+            this.keyboardHookService.KeyboardPressed += this.KeyboardHookService_KeyboardPressed;
+            this.SetupGameActiveChecker();
+        }
+
+        private void SetupGameActiveChecker()
+        {
+            TaskExtensions.RunPeriodicAsync(() =>
+            {
+                var windowHandle = NativeMethods.GetForegroundWindow();
+                var windowNameLength = NativeMethods.GetWindowTextLength(windowHandle);
+                var sb = new StringBuilder(windowNameLength);
+                _ = NativeMethods.GetWindowText(windowHandle, sb, windowNameLength + 1);
+                if (sb.ToString() != "Guild Wars")
+                {
+                    this.gameActive = false;
+                    return;
+                }
+
+                this.gwWindowHwnd = windowHandle;
+                this.gameActive = true;
+            },
+            TimeSpan.Zero,
+            TimeSpan.FromMilliseconds(33),
+            this.cancellationTokenSource.Token);
+        }
+
+        private void KeyboardHookService_KeyboardPressed(object sender, KeyboardHookEventArgs e)
+        {
+            if (this.gameActive && this.liveOptions.Value.ExperimentalFeatures.CanInterceptKeys)
+            {
+                if (e.KeyboardState == KeyboardState.KeyDown)
+                {
+                    this.KeysDown.Add(e.KeyboardInput.Key);
+                }
+                else if (e.KeyboardState == KeyboardState.KeyUp)
+                {
+                    this.KeysDown.Remove(e.KeyboardInput.Key);
+                    return;
+                }
+
+                e.Handled = this.liveOptions.Value.ExperimentalFeatures.Macros
+                    .Where(keyMacro => MacroContainsKey(keyMacro, e.KeyboardInput.Key))
+                    .Where(this.MacroHit)
+                    .Do(this.HandleMacro)
+                    .Any();
+            }
+        }
+
+        public void OnClosing()
+        {
+            this.cancellationTokenSource.Cancel();
+        }
+
+        public void OnStartup()
+        {
+        }
+        
+
+        private bool MacroHit(KeyMacro keyMacro)
+        {
+            return this.KeysDown.Intersect(keyMacro.Keys).OrderBy(key => key).SequenceEqual(keyMacro.Keys.OrderBy(key => key));
+        }
+
+        private void HandleMacro(KeyMacro keyMacro)
+        {
+            // TODO: Propagate key to guildwars executable.
+        }
+
+        private static bool MacroContainsKey(KeyMacro keyMacro, Keys lastKey)
+        {
+            return keyMacro.Keys.Contains(lastKey);
+        }
+    }
+}

Daybreak/Services/Logging/CompositeLogsWritter.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Logging;
+
+namespace Daybreak.Services.Logging
+{
+    public sealed class CompositeLogsWriter : ILogsWriter
+    {
+        private readonly IEnumerable<ILogsWriter> logsWriters;
+
+        public CompositeLogsWriter(params ILogsWriter[] innerLogsWriters)
+        {
+            this.logsWriters = innerLogsWriters;
+        }
+
+        public void WriteLog(Log log)
+        {
+            foreach (var logWriter in this.logsWriters)
+            {
+                logWriter.WriteLog(log);
+            }
+        }
+    }
+}

Daybreak/Services/Logging/DebugLogsWriter.cs

@@ -0,0 +1,13 @@
+using System.Diagnostics;
+using System.Logging;
+
+namespace Daybreak.Services.Logging
+{
+    public sealed class DebugLogsWriter : IDebugLogsWriter
+    {
+        public void WriteLog(Log log)
+        {
+            Debug.WriteLine($"[{log.LogTime}]\t[{log.LogLevel}]\t[{log.Category}]\n{log.Message}");
+        }
+    }
+}

Daybreak/Services/Logging/FlatLoggingDatabase.cs

@@ -1,143 +0,0 @@
-using Daybreak.Exceptions;
-using Daybreak.Models;
-using Daybreak.Utils;
-using System;
-using System.Collections.Generic;
-using System.Extensions;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Daybreak.Services.Logging
-{
-    public class FlatLoggingDatabase : ILoggingDatabase
-    {
-        private const string Path = "logs.db";
-        private const int bufferSize = 10;
-        private const char separator = '§';
-        private readonly string filePath = Path;
-        private readonly List<string> buffer = new List<string>();
-
-        public FlatLoggingDatabase()
-        {
-        }
-
-        public Task<IEnumerable<Log>> GetLogs()
-        {
-            return Task.Run(() =>
-            {
-                lock (this.buffer)
-                {
-                    if (this.buffer.Count > 0)
-                    {
-                        this.WriteBufferToFile();
-                    }
-                }
-
-                return this.GetSerializedLogs().Select(s => s.Deserialize<Log>());
-            });
-        }
-
-        public Task<IEnumerable<Log>> GetLogsByDate(DateTime startTime, DateTime endTime)
-        {
-            return Task.Run(() =>
-            {
-                lock (this.buffer)
-                {
-                    if (this.buffer.Count > 0)
-                    {
-                        this.WriteBufferToFile();
-                    }
-                }
-
-                return this.GetSerializedLogs()
-                    .Select(s => s.Deserialize<Log>())
-                    .Where(l => l.Timestamp > startTime && l.Timestamp < endTime);
-            });
-        }
-
-        public Task<bool> InsertLog(Log log)
-        {
-            return Task.Run(() =>
-            {
-                lock (this.buffer)
-                {
-                    this.buffer.Add(log.Serialize());
-
-                    if (this.buffer.Count > bufferSize)
-                    {
-                        this.WriteBufferToFile();
-                    }
-                }
-
-                return true;
-            });
-        }
-
-        public Task<bool> ClearDatabase()
-        {
-            return Task.Run(() =>
-            {
-                lock (this.buffer)
-                {
-                    this.buffer.Clear();
-                }
-                lock (this.filePath)
-                {
-                    File.WriteAllText(this.filePath, string.Empty);
-                }
-
-                return true;
-            });
-        }
-
-        public void OnClosing()
-        {
-            this.WriteBufferToFile();
-        }
-
-        public void OnStartup()
-        {
-            if (!File.Exists(filePath))
-            {
-                try
-                {
-                    using var fs = File.Create(filePath);
-                }
-                catch (Exception ex)
-                {
-                    throw new FatalException("Could not initialize logging. See inner exception for details.", ex);
-                }
-            }
-        }
-
-        private void WriteBufferToFile()
-        {
-            lock (this.filePath)
-            {
-                File.AppendAllLines(this.filePath, this.buffer.Select(s => s + separator), Encoding.UTF8);
-            }
-            this.buffer.Clear();
-        }
-
-        private IEnumerable<string> GetSerializedLogs()
-        {
-            lock (this.filePath)
-            {
-                var stringBuilder = new StringBuilder();
-                using var fileStream = File.OpenRead(this.filePath);
-                using var streamReader = new StreamReader(fileStream, Encoding.UTF8);
-                string serializedLog = null;
-                while ((serializedLog = streamReader.ReadUntil(separator.ToString())) != null
-                    && serializedLog != string.Empty
-                    && serializedLog != "\r"
-                    && serializedLog != "\n"
-                    && serializedLog != "\r\n")
-                {
-                    yield return serializedLog;
-                }
-            }
-        }
-    }
-}

Daybreak/Services/Logging/IDebugLogsWriter.cs

@@ -0,0 +1,8 @@
+using System.Logging;
+
+namespace Daybreak.Services.Logging
+{
+    public interface IDebugLogsWriter : ILogsWriter
+    {
+    }
+}

Daybreak/Services/Logging/ILogger.cs

@@ -1,11 +0,0 @@
-using Daybreak.Models;
-using System;
-
-namespace Daybreak.Services.Logging
-{
-    public interface ILogger
-    {
-        void Log(LogLevel logLevel, Exception exception);
-        void Log(LogLevel logLevel, string message);
-    }
-}

Daybreak/Services/Logging/ILoggingDatabase.cs

@@ -1,16 +0,0 @@
-using Daybreak.Models;
-using Daybreak.Services.ApplicationLifetime;
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Daybreak.Services.Logging
-{
-    public interface ILoggingDatabase : IApplicationLifetimeService
-    {
-        Task<bool> ClearDatabase();
-        Task<IEnumerable<Log>> GetLogsByDate(DateTime startTime, DateTime endTime);
-        Task<IEnumerable<Log>> GetLogs();
-        Task<bool> InsertLog(Log log);
-    }
-}

Daybreak/Services/Logging/ILogsManager.cs

@@ -0,0 +1,15 @@
+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<Models.Log> GetLogs(Expression<Func<Models.Log, bool>> filter);
+        IEnumerable<Models.Log> GetLogs();
+        int DeleteLogs();
+    }
+}

Daybreak/Services/Logging/JsonLogsManager.cs

@@ -0,0 +1,46 @@
+using LiteDB;
+using System;
+using System.Collections.Generic;
+using System.Extensions;
+using System.Linq.Expressions;
+using System.Logging;
+
+namespace Daybreak.Services.Logging
+{
+    public sealed class JsonLogsManager : ILogsManager
+    {
+        private readonly ILiteDatabase liteDatabase;
+
+        public JsonLogsManager(ILiteDatabase liteDatabase)
+        {
+            this.liteDatabase = liteDatabase.ThrowIfNull(nameof(liteDatabase));
+        }
+
+        public IEnumerable<Models.Log> GetLogs(Expression<Func<Models.Log, bool>> filter)
+        {
+            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)
+        {
+            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<Models.Log>().DeleteAll();
+        }
+    }
+}

Daybreak/Services/Logging/Logger.cs

@@ -1,42 +0,0 @@
-using Daybreak.Models;
-using System;
-
-namespace Daybreak.Services.Logging
-{
-    public class Logger : ILogger
-    {
-        private readonly ILoggingDatabase loggingDatabase;
-        public Logger(ILoggingDatabase loggingDatabase)
-        {
-            this.loggingDatabase = loggingDatabase;
-        }
-
-        public async void Log(LogLevel logLevel, Exception exception)
-        {
-            if (exception is null) throw new ArgumentNullException(nameof(exception));
-
-            await this.loggingDatabase.InsertLog(
-                new Log
-                {
-                    LogLevel = logLevel,
-                    Message = exception.Message,
-                    StackTrace = exception.StackTrace,
-                    Timestamp = DateTime.Now
-                }).ConfigureAwait(false);
-        }
-
-        public async void Log(LogLevel logLevel, string message)
-        {
-            if (message is null) throw new ArgumentNullException(nameof(message));
-
-            await this.loggingDatabase.InsertLog(
-                new Log
-                {
-                    LogLevel = logLevel,
-                    Message = message,
-                    StackTrace = Environment.StackTrace,
-                    Timestamp = DateTime.Now
-                }).ConfigureAwait(false);
-        }
-    }
-}

Daybreak/Services/Navigation/ViewManager.cs

@@ -1,4 +1,6 @@
-using Slim;
+using Daybreak.Models;
+using Microsoft.CorrelationVector;
+using Slim;
 using System;
 using System.Extensions;
 using System.Windows;
@@ -53,9 +55,10 @@ namespace Daybreak.Services.ViewManagement
 
         private void ShowViewInner(Type viewType, object dataContext)
         {
+            var scopedManager = this.serviceManager.CreateScope();
             Application.Current.Dispatcher.Invoke(() =>
             {
-                var view = this.serviceManager.GetService(viewType).As<UserControl>();
+                var view = scopedManager.GetService(viewType).As<UserControl>();
                 this.container.Children.Clear();
                 this.container.Children.Add(view);
                 view.DataContext = dataContext;

Daybreak/Services/Options/ApplicationConfigurationOptionsManager.cs

@@ -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}");
+        }
+    }
+}

Daybreak/Services/Privilege/PrivilegeManager.cs

@@ -1,8 +1,7 @@
 using Daybreak.Models;
-using Daybreak.Services.Logging;
 using Daybreak.Services.ViewManagement;
-using Daybreak.Utils;
 using Daybreak.Views;
+using Microsoft.Extensions.Logging;
 using System.Extensions;
 using System.Security.Principal;
 using System.Windows.Controls;
@@ -14,11 +13,11 @@ namespace Daybreak.Services.Privilege
         public bool AdminPrivileges => new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);
 
         private readonly IViewManager viewManager;
-        private readonly ILogger logger;
+        private readonly ILogger<PrivilegeManager> logger;
 
         public PrivilegeManager(
             IViewManager viewManager,
-            ILogger logger)
+            ILogger<PrivilegeManager> logger)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));

Daybreak/Services/Runtime/IRuntimeStore.cs

@@ -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);
-    }
-}

Daybreak/Services/Runtime/RuntimeStore.cs

@@ -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;
-        }
-    }
-}

Daybreak/Services/Screens/ScreenManager.cs

@@ -1,6 +1,5 @@
 using Daybreak.Models;
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
 using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
@@ -12,13 +11,13 @@ namespace Daybreak.Services.Screens
 {
     public sealed class ScreenManager : IScreenManager
     {
-        private readonly ILogger logger;
+        private readonly ILogger<ScreenManager> logger;
 
         public IEnumerable<Screen> Screens { get; } = WpfScreenHelper.Screen.AllScreens
             .Select((screen, index) => new Screen { Id = index, Size = screen.Bounds });
 
         public ScreenManager(
-            ILogger logger)
+            ILogger<ScreenManager> logger)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
         }

Daybreak/Services/Screenshots/IScreenshotProvider.cs

@@ -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

Daybreak/Services/Screenshots/ScreenshotProvider.cs

@@ -1,5 +1,4 @@
-using Daybreak.Services.Logging;
-using Daybreak.Utils;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Extensions;
@@ -14,11 +13,11 @@ namespace Daybreak.Services.Screenshots
     {
         private const string ScreenshotsFolder = "Screenshots";
 
-        private readonly List<string> Screenshots = new List<string>();
-        private readonly ILogger logger;
+        private readonly List<string> Screenshots = new();
+        private readonly ILogger<ScreenshotProvider> logger;
         private int innerCount = 0;
 
-        public ScreenshotProvider(ILogger logger)
+        public ScreenshotProvider(ILogger<ScreenshotProvider> logger)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
             if (Directory.Exists(ScreenshotsFolder) is false)