Experimental multi-launch support

Change update process to wait for the client to close instead of a static wait.

Daybreak/Configuration/ApplicationConfiguration.cs

@@ -6,6 +6,8 @@ namespace Daybreak.Configuration
     {
         [JsonProperty("GamePath")]
         public string GamePath { get; set; }
+        [JsonProperty("ToolboxPath")]
+        public string ToolboxPath { get; set; }
         [JsonProperty("CharacterName")]
         public string CharacterName { get; set; }
         [JsonProperty("LeftBrowserDefault")]
@@ -18,5 +20,7 @@ namespace Daybreak.Configuration
         public string ProtectedPassword { get; set; }
         [JsonProperty("AddressBarReadonly")]
         public bool AddressBarReadonly { get; set; } = true;
+        [JsonProperty("ExperimentalFeatures")]
+        public ExperimentalFeatures ExperimentalFeatures { get; set; } = new();
     }
 }

Daybreak/Configuration/ExperimentalFeatures.cs

@@ -0,0 +1,7 @@
+namespace Daybreak.Configuration
+{
+    public sealed class ExperimentalFeatures
+    {
+        public bool MultiLaunchSupport { get; set; }
+    }
+}

Daybreak/Configuration/ProjectConfiguration.cs

@@ -4,7 +4,9 @@ using Daybreak.Services.Bloogum;
 using Daybreak.Services.Configuration;
 using Daybreak.Services.Credentials;
 using Daybreak.Services.Logging;
+using Daybreak.Services.Mutex;
 using Daybreak.Services.Screenshots;
+using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Microsoft.Web.WebView2.Core;
@@ -29,7 +31,8 @@ namespace Daybreak.Configuration
             serviceProducer.RegisterSingleton<IScreenshotProvider, ScreenshotProvider>();
             serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
             serviceProducer.RegisterSingleton<IBloogumClient, BloogumClient>();
-            serviceProducer.RegisterSingleton<CoreWebView2Environment, CoreWebView2Environment>((sp) => TaskExtensions.RunSync(() => CoreWebView2Environment.CreateAsync(null, "BrowserData", null)));
+            serviceProducer.RegisterSingleton<IApplicationUpdater, ApplicationUpdater>();
+            serviceProducer.RegisterSingleton<IMutexHandler, MutexHandler>();
         }
         public static void RegisterLifetimeServices(IApplicationLifetimeProducer applicationLifetimeProducer)
         {
@@ -37,13 +40,16 @@ namespace Daybreak.Configuration
 
             applicationLifetimeProducer.RegisterService<ILoggingDatabase>();
             applicationLifetimeProducer.RegisterService<IScreenshotProvider>();
+            applicationLifetimeProducer.RegisterService<IApplicationUpdater>();
         }
         public static void RegisterViews(IViewProducer viewProducer)
         {
             viewProducer.ThrowIfNull(nameof(viewProducer));
 
-            viewProducer.RegisterView<StartupView>();
+            viewProducer.RegisterView<MainView>();
             viewProducer.RegisterView<SettingsView>();
+            viewProducer.RegisterView<AskUpdateView>();
+            viewProducer.RegisterView<UpdateView>();
         }
     }
 }

Daybreak/Controls/ChromiumBrowserWrapper.xaml

@@ -19,8 +19,9 @@
             <RowDefinition Height="*"></RowDefinition>
             <RowDefinition Height="auto"></RowDefinition>
         </Grid.RowDefinitions>
-        <wv2:WebView2 x:Name="WebBrowser" Source="{Binding ElementName=_this, Path=Address, Mode=TwoWay}"></wv2:WebView2>
-        <Grid Grid.Row="1" Background="#80808080">
+        <wv2:WebView2 x:Name="WebBrowser" Source="{Binding ElementName=_this, Path=Address, Mode=TwoWay}"
+                      IsEnabled="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay}"></wv2:WebView2>
+        <Grid Grid.Row="1" Background="#80808080" IsEnabled="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay}">
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="auto"></ColumnDefinition>
                 <ColumnDefinition Width="*"></ColumnDefinition>
@@ -51,15 +52,32 @@
                      Grid.Column="1" IsReadOnly="{Binding ElementName=_this, Path=AddressBarReadonly, Mode=OneWay}" Background="Transparent"
                      BorderThickness="1" VerticalAlignment="Center" VerticalContentAlignment="Center"
                      BorderBrush="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
-                     PreviewKeyDown="TextBox_PreviewKeyDown"></TextBox>
+                     PreviewKeyDown="TextBox_PreviewKeyDown"
+                     IsEnabled="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay}"></TextBox>
             <StackPanel Grid.Column="2" Orientation="Horizontal">
                 <local:StarGlyph Height="30" Width="30" Margin="5"
                              Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+                             IsEnabled="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay}"
                              Clicked="StarGlyph_Clicked" x:Name="FavoriteButton"></local:StarGlyph>
                 <local:MaximizeButton Height="30" Width="30" Margin="5"
                              Foreground="{Binding ElementName=_this, Path=Foreground, Mode=OneWay}"
+                             IsEnabled="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay}"
                              Clicked="MaximizeButton_Clicked"></local:MaximizeButton>
             </StackPanel>
         </Grid>
+        <Grid Grid.RowSpan="2" Background="Gray"
+              Visibility="{Binding ElementName=_this, Path=BrowserSupported, Mode=OneWay,Converter={StaticResource BooleanToVisibilityConverter}}">
+            <StackPanel VerticalAlignment="Center" HorizontalAlignment="Center">
+                <TextBlock Foreground="White" Text="Browser not supported." FontSize="26" TextWrapping="Wrap"></TextBlock>
+                <TextBlock Foreground="White" Text="Download the Evergreen Bootstrapper from here:" FontSize="26" TextWrapping="Wrap" />
+                <TextBox Background="Transparent" BorderBrush="Transparent" BorderThickness="0"
+                         Text="https://go.microsoft.com/fwlink/p/?LinkId=2124703"
+                         IsReadOnly="True" Margin="0, 0, 0, 30" FontSize="22" Foreground="Blue"
+                         PreviewMouseLeftButtonDown="Hyperlink_PreviewMouseLeftButtonDown" Cursor="Hand"
+                         TextWrapping="Wrap"></TextBox>
+                <TextBlock Foreground="White" Text="Restart after the installation." FontSize="26" TextWrapping="Wrap" />
+            </StackPanel>
+        </Grid>
+        
     </Grid>
 </UserControl>

Daybreak/Controls/ChromiumBrowserWrapper.xaml.cs

@@ -1,8 +1,12 @@
 using Daybreak.Launch;
 using Daybreak.Services.Configuration;
+using Daybreak.Services.Logging;
+using Daybreak.Utils;
 using Microsoft.Web.WebView2.Core;
 using System;
+using System.Diagnostics;
 using System.Extensions;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
@@ -14,16 +18,20 @@ namespace Daybreak.Controls
     /// </summary>
     public partial class ChromiumBrowserWrapper : UserControl
     {
+        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 AddressBarReadonlyProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(AddressBarReadonly));
+        public readonly static DependencyProperty BrowserSupportedProperty = DependencyPropertyExtensions.Register<ChromiumBrowserWrapper, bool>(nameof(BrowserSupported), new PropertyMetadata(true));
 
         public event EventHandler<string> FavoriteUriChanged;
         public event EventHandler MaximizeClicked;
 
-        private readonly CoreWebView2Environment coreWebView2Environment;
         private readonly IConfigurationManager configurationManager;
+        private readonly ILogger logger;
+        private CoreWebView2Environment coreWebView2Environment;
 
         public string Address
         {
@@ -45,12 +53,18 @@ namespace Daybreak.Controls
             get => this.GetTypedValue<bool>(AddressBarReadonlyProperty);
             private set => this.SetTypedValue<bool>(AddressBarReadonlyProperty, value);
         }
+        public bool BrowserSupported
+        {
+            get => this.GetTypedValue<bool>(BrowserSupportedProperty);
+            private set => this.SetTypedValue<bool>(BrowserSupportedProperty, value);
+        }
 
         public ChromiumBrowserWrapper()
         {
-            this.coreWebView2Environment = Launcher.ApplicationServiceManager.GetService<CoreWebView2Environment>();
             this.configurationManager = Launcher.ApplicationServiceManager.GetService<IConfigurationManager>();
+            this.logger = Launcher.ApplicationServiceManager.GetService<ILogger>();
             this.InitializeComponent();
+            this.InitializeEnvironment();
             this.InitializeBrowser();
         }
 
@@ -68,13 +82,51 @@ namespace Daybreak.Controls
             this.InitializeBrowser();
         }
 
-        private async void InitializeBrowser()
+        private void InitializeEnvironment()
         {
-            await this.WebBrowser.EnsureCoreWebView2Async(this.coreWebView2Environment);
-            this.AddressBarReadonly = this.configurationManager.GetConfiguration().AddressBarReadonly;
-            this.WebBrowser.CoreWebView2.NewWindowRequested += (browser, args) => args.Handled = true;
-            this.WebBrowser.NavigationStarting += (browser, args) => this.Navigating = true;
-            this.WebBrowser.NavigationCompleted += (browser, args) => this.Navigating = false;
+            try
+            {
+                this.coreWebView2Environment = System.Extensions.TaskExtensions.RunSync(() => CoreWebView2Environment.CreateAsync(null, "BrowserData", null));
+                this.BrowserSupported = true;
+            }
+            catch(Exception e)
+            {
+                this.logger.LogWarning($"Browser initialization failed. Details: {e}");
+                this.BrowserSupported = false;
+            }
+        }
+
+        private async Task InitializeBrowser()
+        {
+            if (this.BrowserSupported is true)
+            {
+                await this.WebBrowser.EnsureCoreWebView2Async(this.coreWebView2Environment);
+                this.AddressBarReadonly = this.configurationManager.GetConfiguration().AddressBarReadonly;
+                this.WebBrowser.CoreWebView2.NewWindowRequested += (browser, args) => args.Handled = true;
+                this.WebBrowser.NavigationStarting += (browser, args) => this.Navigating = true;
+                this.WebBrowser.NavigationCompleted += (browser, args) => this.Navigating = false;
+            }
+        }
+
+        private async void RetryInitializeButton_Clicked(object sender, EventArgs e)
+        {
+            this.InitializeEnvironment();
+            try
+            {
+                await this.InitializeBrowser();
+            }
+            catch
+            {
+                this.BrowserSupported = false;
+            }
+        }
+
+        private void Hyperlink_PreviewMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
+        {
+            if (Uri.TryCreate(BrowserDownloadLink, UriKind.Absolute, out var uri))
+            {
+                Process.Start("explorer.exe", uri.ToString());
+            }
         }
 
         private void TextBox_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)

Daybreak/Daybreak.csproj

@@ -9,7 +9,7 @@
     <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
     <LangVersion>preview</LangVersion>
     <ApplicationIcon>Daybreak.ico</ApplicationIcon>
-    <Version>0.1.2</Version>
+    <Version>0.4.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

Daybreak/Launch/MainWindow.xaml.cs

@@ -1,5 +1,6 @@
 using Daybreak.Services.Bloogum;
 using Daybreak.Services.Screenshots;
+using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Pepa.Wpf.Utilities;
@@ -26,6 +27,7 @@ namespace Daybreak.Launch
         private readonly IViewManager viewManager;
         private readonly IScreenshotProvider screenshotProvider;
         private readonly IBloogumClient bloogumClient;
+        private readonly IApplicationUpdater applicationUpdater;
         private readonly CancellationTokenSource cancellationToken = new();
 
         public string CreditText
@@ -37,18 +39,20 @@ namespace Daybreak.Launch
         public MainWindow(
             IViewManager viewManager,
             IScreenshotProvider screenshotProvider,
-            IBloogumClient bloogumClient)
+            IBloogumClient bloogumClient,
+            IApplicationUpdater applicationUpdater)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.screenshotProvider = screenshotProvider.ThrowIfNull(nameof(screenshotProvider));
             this.bloogumClient = bloogumClient.ThrowIfNull(nameof(bloogumClient));
+            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
             InitializeComponent();
         }
 
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
-            this.viewManager.ShowView<StartupView>();
             this.SetupImageCycle();
+            this.CheckForUpdates();
         }
 
         private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
@@ -145,6 +149,19 @@ namespace Daybreak.Launch
             }
         }
 
+        private async void CheckForUpdates()
+        {
+            var updateAvailable = await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
+            if (updateAvailable)
+            {
+                this.viewManager.ShowView<AskUpdateView>();
+            }
+            else
+            {
+                this.viewManager.ShowView<MainView>();
+            }
+        }
+
         private static Color GetAverageColor(BitmapSource bitmap)
         {
             var format = bitmap.Format;

Daybreak/Models/ExecutionPolicies.cs

@@ -0,0 +1,13 @@
+namespace Daybreak.Models
+{
+    public enum ExecutionPolicies
+    {
+        AllSigned,
+        Bypass,
+        Default,
+        RemoteSigned,
+        Restricted,
+        Undefined,
+        Unrestricted
+    }
+}

Daybreak/Models/UpdateStatus.cs

@@ -0,0 +1,44 @@
+using System.ComponentModel;
+
+namespace Daybreak.Models
+{
+    public sealed class UpdateStatus : INotifyPropertyChanged
+    {
+        public static readonly UpdateStep StartingStep = new("Starting");
+        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.");
+
+        private UpdateStep currentStep = StartingStep;
+
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public UpdateStep CurrentStep
+        {
+            get => this.currentStep;
+            set
+            {
+                this.currentStep = value;
+                this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentStep)));
+            }
+        }
+
+        public class UpdateStep
+        {
+            public string Name { get; }
+            internal UpdateStep(string name)
+            {
+                this.Name = name;
+            }
+        }
+        public class DownloadUpdateStep : UpdateStep
+        {
+            internal DownloadUpdateStep(string name, double progress) : base(name)
+            {
+                this.Progress = progress;
+            }
+
+            public double Progress { get; }
+        }
+    }
+}

Daybreak/Services/ApplicationDetection/ApplicationDetector.cs

@@ -1,27 +1,38 @@
-using Daybreak.Services.Configuration;
+using Daybreak.Models;
+using Daybreak.Services.Configuration;
 using Daybreak.Services.Credentials;
+using Daybreak.Services.Mutex;
+using Microsoft.Win32;
+using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Extensions;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace Daybreak.Services.ApplicationDetection
 {
     public class ApplicationDetector : IApplicationDetector
     {
+        private const string ToolboxProcessName = "GWToolbox";
         private const string ProcessName = "gw";
+        private const string ArenaNetMutex = "AN-Mute";
 
         private readonly IConfigurationManager configurationManager;
         private readonly ICredentialManager credentialManager;
+        private readonly IMutexHandler mutexHandler;
 
-        public bool IsGuildwarsRunning => GuildwarsProcessDetected();
+        public bool IsGuildwarsRunning => this.GuildwarsProcessDetected();
+        public bool IsToolboxRunning => GuildwarsToolboxProcessDetected();
 
         public ApplicationDetector(
             IConfigurationManager configurationManager,
-            ICredentialManager credentialManager)
+            ICredentialManager credentialManager,
+            IMutexHandler mutexHandler)
         {
+            this.mutexHandler = mutexHandler.ThrowIfNull(nameof(mutexHandler));
             this.credentialManager = credentialManager.ThrowIfNull(nameof(credentialManager));
             this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
         }
@@ -29,12 +40,6 @@ namespace Daybreak.Services.ApplicationDetection
         public void LaunchGuildwars()
         {
             var configuration = this.configurationManager.GetConfiguration();
-            var executable = configuration.GamePath;
-            if (File.Exists(executable) is false)
-            {
-                throw new InvalidOperationException($"Guildwars executable doesn't exist at {executable}");
-            }
-
             if (string.IsNullOrEmpty(configuration.CharacterName))
             {
                 throw new InvalidOperationException($"No character name set");
@@ -44,10 +49,12 @@ namespace Daybreak.Services.ApplicationDetection
             auth.Do(
                 onSome: (credentials) =>
                 {
-                    if (Process.Start(executable, new List<string> { "-email", credentials.Username, "-password", credentials.Password, "-character", configuration.CharacterName }) is null)
+                    if (configuration.ExperimentalFeatures.MultiLaunchSupport is true)
                     {
-                        throw new InvalidOperationException($"Unable to launch executable");
+                        ClearGwLocks();
                     }
+
+                    LaunchGuildwarsProcess(credentials.Username, credentials.Password, configuration.CharacterName);
                 },
                 onNone: () =>
                 {
@@ -55,10 +62,103 @@ namespace Daybreak.Services.ApplicationDetection
                 });
         }
 
-        private static bool GuildwarsProcessDetected()
+        public void LaunchGuildwarsToolbox()
         {
-            var process = Process.GetProcessesByName(ProcessName).FirstOrDefault();
-            return process is not null;
+            var configuration = this.configurationManager.GetConfiguration();
+            var executable = configuration.ToolboxPath;
+            if (File.Exists(executable) is false)
+            {
+                throw new InvalidOperationException($"Guildwars executable doesn't exist at {executable}");
+            }
+
+            if (Process.Start(executable) is null)
+            {
+                throw new InvalidOperationException($"Unable to launch {executable}");
+            }
+        }
+
+        private void LaunchGuildwarsProcess(string email, SecureString password, string character)
+        {
+            var executable = this.configurationManager.GetConfiguration().GamePath;
+            if (File.Exists(executable) is false)
+            {
+                throw new InvalidOperationException($"Guildwars executable doesn't exist at {executable}");
+            }
+
+            if (Process.Start(executable, new List<string> { "-email", email, "-password", password, "-character", character }) is null)
+            {
+                throw new InvalidOperationException($"Unable to launch {executable}");
+            }
+        }
+
+        private bool GuildwarsProcessDetected()
+        {
+            if (this.configurationManager.GetConfiguration().ExperimentalFeatures.MultiLaunchSupport is true)
+            {
+                try
+                {
+                    using var stream = File.OpenWrite(this.configurationManager.GetConfiguration().GamePath);
+                    return false;
+                }
+                catch
+                {
+                    return true;
+                }
+            }
+
+            return Process.GetProcessesByName(ProcessName).FirstOrDefault() is not null;
+        }
+
+        private void ClearGwLocks()
+        {
+            this.SetRegistryGuildwarsPath();
+            foreach (var process in Process.GetProcessesByName(ProcessName))
+            {
+                this.mutexHandler.CloseMutex(process, ArenaNetMutex);
+            }
+        }
+
+        private void SetRegistryGuildwarsPath()
+        {
+            var gamePath = this.configurationManager.GetConfiguration().GamePath;
+            var registryKey = GetGuildwarsRegistryKey(true);
+            registryKey.SetValue("Path", gamePath);
+            registryKey.SetValue("Src", gamePath);
+            registryKey.Close();
+        }
+
+        private RegistryKey GetGuildwarsRegistryKey(bool write)
+        {
+            var gwKey = Registry.CurrentUser.OpenSubKey("SOFTWARE")?.OpenSubKey("ArenaNet")?.OpenSubKey("Guild Wars", write);
+            if (gwKey is not null)
+            {
+                return gwKey;
+            }
+
+            gwKey = Registry.CurrentUser.OpenSubKey("SOFTWARE")?.OpenSubKey("WOW6432Node")?.OpenSubKey("ArenaNet")?.OpenSubKey("Guild Wars", write);
+            if (gwKey is not null)
+            {
+                return gwKey;
+            }
+
+            gwKey = Registry.LocalMachine.OpenSubKey("SOFTWARE")?.OpenSubKey("ArenaNet")?.OpenSubKey("Guild Wars", write);
+            if (gwKey is not null)
+            {
+                return gwKey;
+            }
+
+            gwKey = Registry.LocalMachine.OpenSubKey("SOFTWARE")?.OpenSubKey("WOW6432Node")?.OpenSubKey("ArenaNet")?.OpenSubKey("Guild Wars", write);
+            if (gwKey is not null)
+            {
+                return gwKey;
+            }
+
+            throw new InvalidOperationException("Could not find registry key for guildwars.");
+        }
+
+        private static bool GuildwarsToolboxProcessDetected()
+        {
+            return Process.GetProcessesByName(ToolboxProcessName).FirstOrDefault() is not null;
         }
     }
 }

Daybreak/Services/ApplicationDetection/IApplicationDetector.cs

@@ -3,6 +3,8 @@
     public interface IApplicationDetector
     {
         bool IsGuildwarsRunning { get; }
+        bool IsToolboxRunning { get; }
         void LaunchGuildwars();
+        void LaunchGuildwarsToolbox();
     }
 }

Daybreak/Services/Configuration/ConfigurationManager.cs

@@ -1,7 +1,9 @@
 using Daybreak.Configuration;
 using Daybreak.Exceptions;
+using Daybreak.Services.Logging;
 using Daybreak.Utils;
 using System;
+using System.Extensions;
 using System.IO;
 
 namespace Daybreak.Services.Configuration
@@ -11,9 +13,11 @@ namespace Daybreak.Services.Configuration
         private const string ConfigName = "Daybreak.config.json";
 
         private ApplicationConfiguration applicationConfiguration;
+        private readonly ILogger logger;
 
-        public ConfigurationManager()
+        public ConfigurationManager(ILogger logger)
         {
+            this.logger = logger.ThrowIfNull(nameof(logger));
             try
             {
                 var serializedConfig = File.ReadAllText(ConfigName);
@@ -21,7 +25,8 @@ namespace Daybreak.Services.Configuration
             }
             catch(Exception e)
             {
-                throw new FatalException("Failed to load application configuration. See inner exception for details", e);
+                this.logger.LogWarning($"No configuration detected. Loading default configuration. Details: {e}");
+                this.applicationConfiguration = new ApplicationConfiguration();
             }
         }
 

Daybreak/Services/Mutex/IMutexHandler.cs

@@ -0,0 +1,9 @@
+using System.Diagnostics;
+
+namespace Daybreak.Services.Mutex
+{
+    public interface IMutexHandler
+    {
+        void CloseMutex(Process process, string mutexName);
+    }
+}

Daybreak/Services/Mutex/MutexHandler.cs

@@ -0,0 +1,139 @@
+using Pepa.Wpf.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Daybreak.Services.Mutex
+{
+    public sealed class MutexHandler : IMutexHandler
+    {
+        public void CloseMutex(Process process, string mutexName)
+        {
+            CloseHandle(process, mutexName);
+        }
+
+        private static List<NativeMethods.SystemHandleInformation> GetHandles(Process targetProcess, IntPtr systemHandle)
+        {
+            var processHandles = new List<NativeMethods.SystemHandleInformation>();
+            var basePointer = systemHandle.ToInt64();
+            NativeMethods.SystemHandleInformation currentHandleInfo;
+            for (int i = 0; i < Marshal.ReadInt32(systemHandle); i++)
+            {
+                var currentOffset = IntPtr.Size + i * Marshal.SizeOf(typeof(NativeMethods.SystemHandleInformation));
+                currentHandleInfo = (NativeMethods.SystemHandleInformation)Marshal.PtrToStructure(new IntPtr(basePointer + currentOffset), typeof(NativeMethods.SystemHandleInformation));
+                if (currentHandleInfo.OwnerPID == (uint)targetProcess.Id)
+                {
+                    processHandles.Add(currentHandleInfo);
+                }
+            }
+
+            return processHandles;
+        }
+
+        private static void CloseHandle(Process targetProcess, string handleName)
+        {
+            var systemHandles = GetAllHandles();
+            if (systemHandles == IntPtr.Zero)
+            {
+                return;
+            }
+
+            List<NativeMethods.SystemHandleInformation> processHandles = GetHandles(targetProcess, systemHandles);
+            Marshal.FreeHGlobal(systemHandles);
+            var processHandle = NativeMethods.OpenProcess(NativeMethods.ProcessAccessFlags.DupHandle, false, (uint)targetProcess.Id);
+            foreach (var handleInfo in processHandles)
+            {
+                if (GetHandleName(handleInfo, processHandle).Contains(handleName))
+                {
+                    if (CloseOwnedHandle(handleInfo.OwnerPID, new IntPtr(handleInfo.HandleValue)))
+                    {
+                        NativeMethods.CloseHandle(processHandle);
+                        return;
+                    }
+                }
+            }
+
+            NativeMethods.CloseHandle(processHandle);
+            return;
+        }
+
+        private static string GetHandleName(NativeMethods.SystemHandleInformation targetHandleInfo, IntPtr processHandle)
+        {
+            if (targetHandleInfo.AccessMask.ToInt64() == 0x0012019F)
+            {
+                return string.Empty;
+            }
+
+            var thisProcess = Process.GetCurrentProcess().Handle;
+            NativeMethods.DuplicateHandle(processHandle, new IntPtr(targetHandleInfo.HandleValue), thisProcess, out var handle, 0, false, NativeMethods.DuplicateOptions.DUPLICATE_SAME_ACCESS);
+            var bufferSize = GetHandleNameLength(handle);
+            var stringBuffer = Marshal.AllocHGlobal(bufferSize);
+            NativeMethods.NtQueryObject(handle, NativeMethods.ObjectInformationClass.ObjectNameInformation, stringBuffer, bufferSize, out _);
+            NativeMethods.CloseHandle(handle);
+            var handleName = ConvertToString(stringBuffer);
+            Marshal.FreeHGlobal(stringBuffer);
+            return handleName;
+        }
+
+        private static IntPtr GetAllHandles()
+        {
+            int bufferSize = 0x10000;
+            var pSysInfoBuffer = Marshal.AllocHGlobal(bufferSize);
+            var queryResult = NativeMethods.NtQuerySystemInformation(NativeMethods.SystemInformationClass.SystemHandleInformation,
+                pSysInfoBuffer, bufferSize, out _);
+
+            while (queryResult == NativeMethods.NtStatus.STATUS_INFO_LENGTH_MISMATCH)
+            {
+                Marshal.FreeHGlobal(pSysInfoBuffer);
+                bufferSize *= 2;
+                pSysInfoBuffer = Marshal.AllocHGlobal(bufferSize);
+                queryResult = NativeMethods.NtQuerySystemInformation(NativeMethods.SystemInformationClass.SystemHandleInformation,
+                    pSysInfoBuffer, bufferSize, out _);
+            }
+
+            if (queryResult == NativeMethods.NtStatus.STATUS_SUCCESS)
+            {
+                return pSysInfoBuffer;
+            }
+            else
+            {
+                Marshal.FreeHGlobal(pSysInfoBuffer);
+                return IntPtr.Zero;
+            }
+        }
+
+        private static int GetHandleNameLength(IntPtr handle)
+        {
+            var infoBufferSize = Marshal.SizeOf(typeof(NativeMethods.ObjectBasicInformation));
+            var pInfoBuffer = Marshal.AllocHGlobal(infoBufferSize);
+            NativeMethods.NtQueryObject(handle, NativeMethods.ObjectInformationClass.ObjectBasicInformation, pInfoBuffer, infoBufferSize, out _);
+            NativeMethods.ObjectBasicInformation objInfo = (NativeMethods.ObjectBasicInformation)Marshal.PtrToStructure(pInfoBuffer, typeof(NativeMethods.ObjectBasicInformation));
+            Marshal.FreeHGlobal(pInfoBuffer);
+            if (objInfo.NameInformationLength == 0)
+            {
+                return 0x100;
+            }
+            else
+            {
+                return (int)objInfo.NameInformationLength;
+            }
+        }
+
+        private static string ConvertToString(IntPtr stringBuffer)
+        {
+            var baseAddress = stringBuffer.ToInt64();
+            var offset = IntPtr.Size * 2;
+            var handleName = Marshal.PtrToStringUni(new IntPtr(baseAddress + offset));
+            return handleName;
+        }
+
+        private static bool CloseOwnedHandle(uint processId, IntPtr handleToClose)
+        {
+            var processHandle = NativeMethods.OpenProcess(NativeMethods.ProcessAccessFlags.All, false, processId);
+            var success = NativeMethods.DuplicateHandle(processHandle, handleToClose, IntPtr.Zero, out _, 0, false, NativeMethods.DuplicateOptions.DUPLICATE_CLOSE_SOURCE);
+            NativeMethods.CloseHandle(processHandle);
+            return success;
+        }
+    }
+}

Daybreak/Services/Updater/ApplicationUpdater.cs

@@ -0,0 +1,326 @@
+using Daybreak.Models;
+using Daybreak.Services.Logging;
+using Daybreak.Utils;
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Extensions;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.Updater
+{
+    public sealed class ApplicationUpdater : IApplicationUpdater
+    {
+        private const string ExecutionPolicyKey = "ExecutionPolicy";
+        private const string UpdatedKey = "Updating";
+        private const string RegistryKey = "Daybreak";
+        private const string ExtractAndRunPs1 = "ExtractAndRun.ps1";
+        private const string TempFile = "tempfile.zip";
+        private const string VersionTag = "{VERSION}";
+        private const string InputFileTag = "{INPUTFILE}";
+        private const string OutputPathTag = "{OUTPUTPATH}";
+        private const string ExecutionPolicyTag = "{EXECUTIONPOLICY}";
+        private const string ProcessIdTag = "{PROCESSID}";
+        private const string Url = "https://github.com/AlexMacocian/Daybreak/releases/latest";
+        private const string DownloadUrl = $"https://github.com/AlexMacocian/Daybreak/releases/download/v{VersionTag}/Daybreakv{VersionTag}.zip";
+        private const string GetExecutionPolicyCommand = "Get-ExecutionPolicy -Scope CurrentUser";
+        private const string SetExecutionPolicyCommand = $"Set-ExecutionPolicy {ExecutionPolicyTag} -Scope CurrentUser";
+        private const string WaitCommand = $"Wait-Process -Id {ProcessIdTag}";
+        private const string ExtractCommandTemplate = $"Expand-Archive -Path '{InputFileTag}' -DestinationPath '{OutputPathTag}' -Force";
+        private const string RunClientCommand = @".\Daybreak.exe";
+        private const string RemoveTempFile = $"Remove-item {TempFile}";
+        private const string RemovePs1 = $"Remove-item {ExtractAndRunPs1}";
+
+        private readonly ILogger logger;
+        private readonly HttpClient httpClient = new();
+
+        public string CurrentVersion => Assembly.GetExecutingAssembly().GetName().Version.ToString();
+
+        public ApplicationUpdater(ILogger logger)
+        {
+            this.logger = logger.ThrowIfNull(nameof(logger));
+        }
+
+        public async Task<bool> DownloadUpdate(UpdateStatus updateStatus)
+        {
+            updateStatus.CurrentStep = UpdateStatus.CheckingLatestVersion;
+            var latestVersion = (await this.GetLatestVersion()).ExtractValue();
+            if (latestVersion is null)
+            {
+                this.logger.LogWarning("Failed to retrieve latest version. Aborting update");
+                return false;
+            }
+
+            using var downloadLatestResponse = await this.httpClient.GetAsync(
+                DownloadUrl.Replace(VersionTag, latestVersion));
+
+            if (downloadLatestResponse.IsSuccessStatusCode is false)
+            {
+                this.logger.LogWarning("Failed to download latest version. Aborting udpate");
+                return false;
+            }
+
+            this.logger.LogInformation("Beginning update download");
+            var downloadStream = await downloadLatestResponse.Content.ReadAsStreamAsync();
+            var fileStream = File.OpenWrite(TempFile);
+            var downloadSize = (double)downloadStream.Length;
+            var buffer = new byte[1024];
+            var length = 0;
+            double downloaded = 0;
+            var tickTime = DateTime.Now;
+            while (downloadStream.CanRead && (length = await downloadStream.ReadAsync(buffer)) > 0)
+            {
+                downloaded += length;
+                await fileStream.WriteAsync(buffer, 0, length);
+                if ((DateTime.Now - tickTime).TotalMilliseconds > 50)
+                {
+                    tickTime = DateTime.Now;
+                    updateStatus.CurrentStep = UpdateStatus.Downloading(downloaded / downloadSize);
+                }
+            }
+
+            updateStatus.CurrentStep = UpdateStatus.Downloading(1);
+            updateStatus.CurrentStep = UpdateStatus.DownloadFinished;
+            fileStream.Close();
+            this.logger.LogInformation("Downloaded update");
+            return true;
+        }
+
+        public async Task<bool> UpdateAvailable()
+        {
+            var version = string.Join('.', this.CurrentVersion.Split('.').Take(3));
+            var maybeLatestVersion = await this.GetLatestVersion();
+            return maybeLatestVersion.Switch(
+                onSome: latestVersion => string.Compare(version, latestVersion, true) < 0,
+                onNone: () =>
+                {
+                    this.logger.LogWarning("Failed to retrieve latest version");
+                    return false;
+                }).ExtractValue();
+        }
+
+        public void FinalizeUpdate()
+        {
+            var maybeExecutionPolicy = this.RetrieveExecutionPolicy();
+            maybeExecutionPolicy.DoAny(
+                onNone: () =>
+                {
+                    throw new InvalidOperationException("Failed to retrieve execution policy");
+                });
+
+            var executionPolicy = maybeExecutionPolicy.ExtractValue();
+            if (executionPolicy is not ExecutionPolicies.Bypass ||
+                executionPolicy is not ExecutionPolicies.Unrestricted)
+            {
+                this.logger.LogInformation($"Execution policy is set to {executionPolicy}. Setting to {ExecutionPolicies.Bypass}");
+            }
+
+            SaveExecutionPolicyValueToRegistry(executionPolicy);
+            MarkUpdateInRegistry();
+            this.SetExecutionPolicy(ExecutionPolicies.Bypass);
+            this.LaunchExtractor();
+        }
+
+        public void OnStartup()
+        {
+            if (UpdateMarkedInRegistry())
+            {
+                UnmarkUpdateInRegistry();
+                var maybeExecutionPolicy = LoadExecutionPolicyValueFromRegistry();
+                maybeExecutionPolicy.Do(
+                    onSome: policy =>
+                    {
+                        SetExecutionPolicy(policy);
+                    },
+                    onNone: () =>
+                    {
+                        throw new InvalidOperationException("Found update marked in registry but no execution policy");
+                    });
+            }
+        }
+
+        public void OnClosing()
+        {
+        }
+
+        private async Task<Optional<string>> GetLatestVersion()
+        {
+            using var response = await this.httpClient.GetAsync(Url);
+            if (response.IsSuccessStatusCode)
+            {
+                var versionTag = response.RequestMessage.RequestUri.ToString().Split('/').Last().TrimStart('v');
+                return versionTag;
+            }
+
+            return Optional.None<string>();
+        }
+
+        private Optional<ExecutionPolicies> RetrieveExecutionPolicy()
+        {
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "powershell",
+                    Arguments = GetExecutionPolicyCommand,
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true,
+                    RedirectStandardOutput = true
+                }
+            };
+            process.Start();
+            this.logger.LogInformation("Checking current execution policy");
+            var output = process.StandardOutput.ReadToEnd();
+            if (!Enum.TryParse(typeof(ExecutionPolicies), output, out var executionPolicy))
+            {
+                var error = process.StandardError.ReadToEnd();
+                this.logger.LogError($"Failed to retrieve current user execution policy. Stdout: {output}. Stderr: {error}");
+                return Optional.None<ExecutionPolicies>();
+            }
+
+            return executionPolicy.Cast<ExecutionPolicies>();
+        }
+
+        private void SetExecutionPolicy(ExecutionPolicies executionPolicy)
+        {
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "powershell",
+                    Arguments = SetExecutionPolicyCommand.Replace(ExecutionPolicyTag, executionPolicy.ToString()),
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true,
+                    RedirectStandardOutput = true
+                }
+            };
+            process.Start();
+            this.logger.LogInformation($"Setting execution policy to {executionPolicy}");
+            var output = process.StandardOutput.ReadToEnd();
+            if (!string.IsNullOrWhiteSpace(output))
+            {
+                var error = process.StandardError.ReadToEnd();
+                throw new InvalidOperationException($"Failed to set execution policy to {executionPolicy}. Stdout: {output}. Stderr: {error}");
+            }
+        }
+
+        private void LaunchExtractor()
+        {
+            File.WriteAllLines(ExtractAndRunPs1, new List<string>()
+            {
+                WaitCommand.Replace(ProcessIdTag, Environment.ProcessId.ToString()),
+                ExtractCommandTemplate
+                    .Replace(InputFileTag, Path.GetFullPath(TempFile))
+                    .Replace(OutputPathTag, Directory.GetCurrentDirectory()),
+                RemoveTempFile,
+                RemovePs1,
+                RunClientCommand
+            });
+            var process = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "powershell.exe",
+                    Arguments = $@"{Directory.GetCurrentDirectory()}\{ExtractAndRunPs1}",
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardInput = true,
+                    RedirectStandardOutput = true,
+                    WindowStyle = ProcessWindowStyle.Maximized,
+                    WorkingDirectory = Directory.GetCurrentDirectory()
+                },
+            };
+            this.logger.LogInformation("Created extractor script. Attempting to launch powershell");
+            if (process.Start() is false)
+            {
+                throw new InvalidOperationException("Failed to create and start powershell script");
+            }
+        }
+
+        private static void MarkUpdateInRegistry()
+        {
+            var homeRegistryKey = GetOrCreateHomeKey();
+            homeRegistryKey.SetValue(UpdatedKey, true);
+            homeRegistryKey.Close();
+        }
+
+        private static void UnmarkUpdateInRegistry()
+        {
+            var homeRegistryKey = GetOrCreateHomeKey();
+            homeRegistryKey.SetValue(UpdatedKey, false);
+            homeRegistryKey.Close();
+        }
+
+        private static bool UpdateMarkedInRegistry()
+        {
+            var homeRegistryKey = GetOrCreateHomeKey();
+            var update = homeRegistryKey.GetValue(UpdatedKey);
+            homeRegistryKey.Close();
+            if (update is string updateString)
+            {
+                if (bool.TryParse(updateString, out var updateValue))
+                {
+                    return updateValue;
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Found update value {updateString} in registry");
+                }
+            }
+
+            return false;
+        }
+
+        private static void SaveExecutionPolicyValueToRegistry(ExecutionPolicies executionPolicy)
+        {
+            var homeRegistryKey = GetOrCreateHomeKey();
+            homeRegistryKey.SetValue(ExecutionPolicyKey, executionPolicy.ToString());
+            homeRegistryKey.Close();
+        }
+
+        private static Optional<ExecutionPolicies> LoadExecutionPolicyValueFromRegistry()
+        {
+            var homeRegistryKey = GetOrCreateHomeKey();
+            var executionPolicy = homeRegistryKey.GetValue(ExecutionPolicyKey);
+            homeRegistryKey.Close();
+            
+            if (executionPolicy is null)
+            {
+                return Optional.None<ExecutionPolicies>();
+            }
+            else if (executionPolicy is string executionPolicyString)
+            {
+                if (Enum.TryParse<ExecutionPolicies>(executionPolicyString, out var executionPolicyValue))
+                {
+                    return executionPolicyValue;
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Found execution policy with value {executionPolicy}");
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException($"Found execution policy of type {executionPolicy.GetType()}.");
+            }
+        }
+
+        private static RegistryKey GetOrCreateHomeKey()
+        {
+            var homeRegistryKey = Registry.CurrentUser.OpenSubKey("Software", true).OpenSubKey(RegistryKey, true);
+            if (homeRegistryKey is null)
+            {
+                homeRegistryKey = Registry.CurrentUser.OpenSubKey("Software", true).CreateSubKey(RegistryKey, true);
+            }
+
+            return homeRegistryKey;
+        }
+    }
+}

Daybreak/Services/Updater/IApplicationUpdater.cs

@@ -0,0 +1,14 @@
+using Daybreak.Models;
+using Daybreak.Services.ApplicationLifetime;
+using System.Threading.Tasks;
+
+namespace Daybreak.Services.Updater
+{
+    public interface IApplicationUpdater : IApplicationLifetimeService
+    {
+        string CurrentVersion { get; }
+        void FinalizeUpdate();
+        Task<bool> UpdateAvailable();
+        Task<bool> DownloadUpdate(UpdateStatus updateStatus);
+    }
+}

Daybreak/Utils/NativeMethods.cs

@@ -1,13 +1,106 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
 
 namespace Pepa.Wpf.Utilities
 {
     static class NativeMethods
     {
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        public struct SystemHandleInformation
+        {
+            public uint OwnerPID;
+            public byte ObjectType;
+            public byte HandleFlags;
+            public ushort HandleValue;
+            public UIntPtr ObjectPointer;
+            public IntPtr AccessMask;
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ObjectBasicInformation
+        {
+            public uint Attributes;
+            public uint GrantedAccess;
+            public uint HandleCount;
+            public uint PointerCount;
+            public uint PagedPoolUsage;
+            public uint NonPagedPoolUsage;
+            public uint Reserved1;
+            public uint Reserved2;
+            public uint Reserved3;
+            public uint NameInformationLength;
+            public uint TypeInformationLength;
+            public uint SecurityDescriptorLength;
+            public FILETIME CreateTime;
+        }
+        [StructLayout(LayoutKind.Sequential)]
+        public struct IoStatusBlock
+        {
+            public uint Status;
+            public ulong Information;
+        }
+
+        [Flags]
+        public enum DuplicateOptions : uint
+        {
+            DUPLICATE_CLOSE_SOURCE = 0x00000001,
+            DUPLICATE_SAME_ACCESS = 0x00000002
+        }
+        [Flags]
+        public enum ProcessAccessFlags : uint
+        {
+            All = 0x001F0FFF,
+            Terminate = 0x00000001,
+            CreateThread = 0x00000002,
+            VMOperation = 0x00000008,
+            VMRead = 0x00000010,
+            VMWrite = 0x00000020,
+            DupHandle = 0x00000040,
+            SetInformation = 0x00000200,
+            QueryInformation = 0x00000400,
+            Synchronize = 0x00100000
+        }
+        [Flags]
+        public enum NtStatus : uint
+        {
+            STATUS_SUCCESS = 0x00000000,
+            STATUS_INFO_LENGTH_MISMATCH = 0xC0000004
+        }
+        [Flags]
+        public enum ObjectInformationClass : uint
+        {
+            ObjectBasicInformation = 0,
+            ObjectNameInformation = 1,
+            ObjectTypeInformation = 2,
+            ObjectAllTypesInformation = 3,
+            ObjectHandleInformation = 4
+        }
+        [Flags]
+        public enum SystemInformationClass : uint
+        {
+            SystemHandleInformation = 16
+        }
+        [Flags]
+        public enum FileInformationClass
+        {
+            FileNameInformation = 9
+        }
+
         public const int WM_SYSCOMMAND = 0x112;
 
         [DllImport("user32.dll", CharSet = CharSet.Auto)]
         public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+        [DllImport("kernel32.dll")]
+        public static extern bool CloseHandle(IntPtr hObject);
+        [DllImport("kernel32.dll")]
+        public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, DuplicateOptions dwOptions);
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, bool bInheritHandle, uint dwProcessID);
+        [DllImport("ntdll.dll", SetLastError = true)]
+        public static extern NtStatus NtQueryInformationFile(IntPtr FileHandle, ref IoStatusBlock IoStatusBlock, IntPtr FileInformation, int FileInformationLength, FileInformationClass FileInformationClass);
+        [DllImport("ntdll.dll")]
+        public static extern NtStatus NtQueryObject(IntPtr ObjectHandle, ObjectInformationClass ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength, out int ReturnLength);
+        [DllImport("ntdll.dll")]
+        public static extern NtStatus NtQuerySystemInformation(SystemInformationClass SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, out int ReturnLength);
     }
-}
+}

Daybreak/Views/AskUpdateView.xaml

@@ -0,0 +1,21 @@
+<UserControl x:Class="Daybreak.Views.AskUpdateView"
+             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.Views"
+             mc:Ignorable="d"
+             xmlns:controls="clr-namespace:Daybreak.Controls"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid VerticalAlignment="Center" HorizontalAlignment="Center" Width="400" Height="200"
+          Background="White">
+        <TextBlock Text="An update has been detected. Do you wish to update?" FontSize="20" TextWrapping="Wrap"
+                   Foreground="Black"></TextBlock>
+        <controls:OpaqueButton Text="No" Foreground="Black" TransparentBackground="Gray" BackgroundOpacity="0.2" Width="50" Height="30"
+                               FontSize="16" HorizontalAlignment="Center" Margin="0, 0, 80, 0"
+                               Clicked="NoButton_Clicked"></controls:OpaqueButton>
+        <controls:OpaqueButton Text="Yes" Foreground="Black" TransparentBackground="Gray" BackgroundOpacity="0.2" Width="50" Height="30"
+                               FontSize="16" HorizontalAlignment="Center" Margin="80, 0, 0, 0"
+                               Clicked="YesButton_Clicked"></controls:OpaqueButton>
+    </Grid>
+</UserControl>

Daybreak/Views/AskUpdateView.xaml.cs

@@ -0,0 +1,42 @@
+using Daybreak.Services.Logging;
+using Daybreak.Services.Updater;
+using Daybreak.Services.ViewManagement;
+using Daybreak.Utils;
+using System.Extensions;
+using System.Windows.Controls;
+
+namespace Daybreak.Views
+{
+    /// <summary>
+    /// Interaction logic for AskUpdateView.xaml
+    /// </summary>
+    public partial class AskUpdateView : UserControl
+    {
+        private readonly IApplicationUpdater applicationUpdater;
+        private readonly ILogger logger;
+        private readonly IViewManager viewManager;
+
+        public AskUpdateView(
+            IApplicationUpdater applicationUpdater,
+            ILogger logger,
+            IViewManager viewManager)
+        {
+            this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
+            this.logger = logger.ThrowIfNull(nameof(logger));
+            this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
+            this.InitializeComponent();
+        }
+
+        private void NoButton_Clicked(object sender, System.EventArgs e)
+        {
+            this.logger.LogInformation("User declined update");
+            this.viewManager.ShowView<MainView>();
+        }
+
+        private void YesButton_Clicked(object sender, System.EventArgs e)
+        {
+            this.logger.LogInformation("User accepted update");
+            this.viewManager.ShowView<UpdateView>();
+        }
+    }
+}

Daybreak/Views/MainView.xaml

@@ -1,4 +1,4 @@
-<UserControl x:Class="Daybreak.Views.StartupView"
+<UserControl x:Class="Daybreak.Views.MainView"
              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" 
@@ -25,9 +25,13 @@
             <ColumnDefinition Width="*"></ColumnDefinition>
         </Grid.ColumnDefinitions>
         <controls:OpaqueButton Text="Launch game" Highlight="White" TransparentBackground="Black" HighlightOpacity="0.3" BackgroundOpacity="0.2"
-                               Foreground="White" FontSize="36" Width="250" Height="60" VerticalAlignment="Bottom" Margin="0, 0, 0, 30"
+                               Foreground="White" FontSize="36" Width="250" Height="60" VerticalAlignment="Bottom"
                                IsEnabled="{Binding ElementName=_this, Path=LaunchButtonEnabled, Mode=OneWay}"
-                               Clicked="OpaqueButton_Clicked" Grid.Row="1" Grid.ColumnSpan="3"></controls:OpaqueButton>
+                               Clicked="LaunchButton_Clicked" Grid.Row="0" Grid.ColumnSpan="3"></controls:OpaqueButton>
+        <controls:OpaqueButton Text="Launch toolbox" Highlight="White" TransparentBackground="Black" HighlightOpacity="0.3" BackgroundOpacity="0.2"
+                               Foreground="White" FontSize="24" Width="200" Height="40" Margin="0, 10, 0, 10"
+                               IsEnabled="{Binding ElementName=_this, Path=LaunchToolboxButtonEnabled, Mode=OneWay}"
+                               Clicked="LaunchToolboxButton_Clicked" Grid.Row="1" Grid.ColumnSpan="3"></controls:OpaqueButton>
         <Grid x:Name="RightContainer" Grid.Column="2" Margin="10">
             <controls:ChromiumBrowserWrapper Address="{Binding ElementName=_this, Path=RightBrowserAddress, Mode=OneWay}"
                                              Foreground="White" FavoriteUriChanged="RightBrowser_FavoriteUriChanged"

Daybreak/Views/MainView.xaml.cs

@@ -14,18 +14,20 @@ namespace Daybreak.Views
     /// <summary>
     /// Interaction logic for StartupView.xaml
     /// </summary>
-    public partial class StartupView : UserControl
+    public partial class MainView : UserControl
     {
         public static readonly DependencyProperty LaunchButtonEnabledProperty =
-            DependencyPropertyExtensions.Register<StartupView, bool>(nameof(LaunchButtonEnabled));
+            DependencyPropertyExtensions.Register<MainView, bool>(nameof(LaunchButtonEnabled));
+        public static readonly DependencyProperty LaunchToolboxButtonEnabledProperty =
+            DependencyPropertyExtensions.Register<MainView, bool>(nameof(LaunchToolboxButtonEnabled));
         public static readonly DependencyProperty RightBrowserAddressProperty =
-            DependencyPropertyExtensions.Register<StartupView, string>(nameof(RightBrowserAddress));
+            DependencyPropertyExtensions.Register<MainView, string>(nameof(RightBrowserAddress));
         public static readonly DependencyProperty LeftBrowserAddressProperty =
-            DependencyPropertyExtensions.Register<StartupView, string>(nameof(LeftBrowserAddress));
+            DependencyPropertyExtensions.Register<MainView, string>(nameof(LeftBrowserAddress));
         public static readonly DependencyProperty RightBrowserFavoriteAddressProperty =
-            DependencyPropertyExtensions.Register<StartupView, string>(nameof(RightBrowserFavoriteAddress));
+            DependencyPropertyExtensions.Register<MainView, string>(nameof(RightBrowserFavoriteAddress));
         public static readonly DependencyProperty LeftBrowserFavoriteAddressProperty =
-            DependencyPropertyExtensions.Register<StartupView, string>(nameof(LeftBrowserFavoriteAddress));
+            DependencyPropertyExtensions.Register<MainView, string>(nameof(LeftBrowserFavoriteAddress));
 
         private readonly IApplicationDetector applicationDetector;
         private readonly IViewManager viewManager;
@@ -60,8 +62,13 @@ namespace Daybreak.Views
             get => this.GetTypedValue<bool>(LaunchButtonEnabledProperty);
             set => this.SetTypedValue(LaunchButtonEnabledProperty, value);
         }
+        public bool LaunchToolboxButtonEnabled
+        {
+            get => this.GetTypedValue<bool>(LaunchToolboxButtonEnabledProperty);
+            set => this.SetTypedValue(LaunchToolboxButtonEnabledProperty, value);
+        }
 
-        public StartupView(
+        public MainView(
             IApplicationDetector applicationDetector,
             IViewManager viewManager,
             IConfigurationManager configurationManager)
@@ -90,14 +97,8 @@ namespace Daybreak.Views
 
         private void CheckGameState()
         {
-            if (applicationDetector.IsGuildwarsRunning)
-            {
-                this.LaunchButtonEnabled = false;
-            }
-            else
-            {
-                this.LaunchButtonEnabled = true;
-            }
+            this.LaunchButtonEnabled = applicationDetector.IsGuildwarsRunning is false;
+            this.LaunchToolboxButtonEnabled = applicationDetector.IsToolboxRunning is false;
         }
 
         private void StartupView_Loaded(object sender, RoutedEventArgs e)
@@ -109,7 +110,7 @@ namespace Daybreak.Views
             this.cancellationTokenSource.Cancel();
         }
 
-        private void OpaqueButton_Clicked(object sender, EventArgs e)
+        private void LaunchButton_Clicked(object sender, EventArgs e)
         {
             try
             {
@@ -121,6 +122,18 @@ namespace Daybreak.Views
             }
         }
 
+        private void LaunchToolboxButton_Clicked(object sender, EventArgs e)
+        {
+            try
+            {
+                this.applicationDetector.LaunchGuildwarsToolbox();
+            }
+            catch
+            {
+                this.viewManager.ShowView<SettingsView>();
+            }
+        }
+
         private void LeftBrowser_FavoriteUriChanged(object sender, string e)
         {
             var config = this.configurationManager.GetConfiguration();

Daybreak/Views/SettingsView.xaml

@@ -16,6 +16,9 @@
             <RowDefinition Height="auto"></RowDefinition>
             <RowDefinition Height="auto"></RowDefinition>
             <RowDefinition Height="auto"></RowDefinition>
+            <RowDefinition Height="auto"></RowDefinition>
+            <RowDefinition Height="auto"></RowDefinition>
+            <RowDefinition Height="auto"></RowDefinition>
         </Grid.RowDefinitions>
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="auto"></ColumnDefinition>
@@ -39,9 +42,19 @@
                  x:Name="GamePathTextbox" FontSize="22" Margin="0, 0, 30, 0" Background="Transparent" Foreground="White"></TextBox>
         <controls:FilePickerGlyph Grid.Row="4" Grid.Column="1" Height="30" Width="30" HorizontalAlignment="Right"
                                   Foreground="White" BorderBrush="Gray" BorderThickness="1"
-                                  Clicked="FilePickerGlyph_Clicked"></controls:FilePickerGlyph>
-        <TextBlock Text="Address bar readonly: " FontSize="22" Foreground="White" Grid.Row="5"/>
+                                  Clicked="GameFilePickerGlyph_Clicked"></controls:FilePickerGlyph>
+        <TextBlock Text="Toolbox path: " FontSize="22" Foreground="White" Grid.Row="5"></TextBlock>
         <TextBox Grid.Column="1" HorizontalAlignment="Stretch" HorizontalContentAlignment="Stretch" Grid.Row="5"
+                 x:Name="ToolboxPathTextbox" FontSize="22" Margin="0, 0, 30, 0" Background="Transparent" Foreground="White"></TextBox>
+        <controls:FilePickerGlyph Grid.Row="5" Grid.Column="1" Height="30" Width="30" HorizontalAlignment="Right"
+                                  Foreground="White" BorderBrush="Gray" BorderThickness="1"
+                                  Clicked="ToolboxFilePickerGlyph_Clicked"></controls:FilePickerGlyph>
+        <TextBlock Text="Address bar readonly: " FontSize="22" Foreground="White" Grid.Row="6"/>
+        <TextBox Grid.Column="1" HorizontalAlignment="Stretch" HorizontalContentAlignment="Stretch" Grid.Row="6"
                  x:Name="AddressBarReadonlyTextbox" FontSize="22" Background="Transparent" Foreground="White"></TextBox>
+        <TextBlock Text="Experimental" FontSize="26" Foreground="White" Grid.Row="7" Grid.ColumnSpan="2" HorizontalAlignment="Center"/>
+        <TextBlock Text="Multi-launch support: " FontSize="22" Foreground="White" Grid.Row="8"/>
+        <TextBox Grid.Column="1" HorizontalAlignment="Stretch" HorizontalContentAlignment="Stretch" Grid.Row="8"
+                 x:Name="MultiLaunchSupportTextbox" FontSize="22" Background="Transparent" Foreground="White"></TextBox>
     </Grid>
 </UserControl>

Daybreak/Views/SettingsView.xaml.cs

@@ -43,6 +43,8 @@ namespace Daybreak.Views
             this.AddressBarReadonlyTextbox.Text = config.AddressBarReadonly.ToString();
             this.CharacterTextbox.Text = config.CharacterName;
             this.GamePathTextbox.Text = config.GamePath;
+            this.ToolboxPathTextbox.Text = config.ToolboxPath;
+            this.MultiLaunchSupportTextbox.Text = config.ExperimentalFeatures.MultiLaunchSupport.ToString();
         }
 
         private void SaveButton_Clicked(object sender, System.EventArgs e)
@@ -50,17 +52,23 @@ namespace Daybreak.Views
             var currentConfig = this.configurationManager.GetConfiguration();
             currentConfig.CharacterName = this.CharacterTextbox.Text;
             currentConfig.GamePath = this.GamePathTextbox.Text;
+            currentConfig.ToolboxPath = this.ToolboxPathTextbox.Text;
             if (bool.TryParse(this.AddressBarReadonlyTextbox.Text, out var addressBarReadonly))
             {
                 currentConfig.AddressBarReadonly = addressBarReadonly;
             }
 
+            if (bool.TryParse(this.MultiLaunchSupportTextbox.Text, out var multiLaunchSupport))
+            {
+                currentConfig.ExperimentalFeatures.MultiLaunchSupport = multiLaunchSupport;
+            }
+
             this.configurationManager.SaveConfiguration(currentConfig);
             this.credentialManager.StoreCredentials(new LoginCredentials { Username = this.UsernameTextbox.Text, Password = this.PasswordBox.Password });
-            this.viewManager.ShowView<StartupView>();
+            this.viewManager.ShowView<MainView>();
         }
 
-        private void FilePickerGlyph_Clicked(object sender, System.EventArgs e)
+        private void GameFilePickerGlyph_Clicked(object sender, System.EventArgs e)
         {
             var filePicker = new OpenFileDialog()
             {
@@ -75,9 +83,24 @@ namespace Daybreak.Views
             }
         }
 
+        private void ToolboxFilePickerGlyph_Clicked(object sender, System.EventArgs e)
+        {
+            var filePicker = new OpenFileDialog()
+            {
+                CheckFileExists = true,
+                CheckPathExists = true,
+                DefaultExt = "exe",
+                Multiselect = false
+            };
+            if (filePicker.ShowDialog() is true)
+            {
+                this.ToolboxPathTextbox.Text = filePicker.FileName;
+            }
+        }
+
         private void BackButton_Clicked(object sender, System.EventArgs e)
         {
-            this.viewManager.ShowView<StartupView>();
+            this.viewManager.ShowView<MainView>();
         }
     }
 }

Daybreak/Views/UpdateView.xaml

@@ -0,0 +1,22 @@
+<UserControl x:Class="Daybreak.Views.UpdateView"
+             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.Views"
+             mc:Ignorable="d"
+             x:Name="_this"
+             xmlns:controls="clr-namespace:Daybreak.Controls"
+             Loaded="UpdateView_Loaded"
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid VerticalAlignment="Center" HorizontalAlignment="Center" Background="White" MinHeight="200" MinWidth="400">
+        <StackPanel VerticalAlignment="Center">
+            <TextBlock Text="{Binding ElementName=_this, Path=Description, Mode=OneWay}" Margin="10, 0, 10, 10" Foreground="Black"
+                       TextWrapping="Wrap"></TextBlock>
+            <ProgressBar Minimum="0" Maximum="100" Value="{Binding ElementName=_this, Path=ProgressValue, Mode=OneWay}" Width="300" Height="20"></ProgressBar>
+            <controls:OpaqueButton Text="Ok" BackgroundOpacity="0.2" TransparentBackground="Gray" HorizontalAlignment="Center" Margin="10" Width="30" Height="20"
+                                   IsEnabled="{Binding ElementName=_this, Path=ContinueButtonEnabled, Mode=OneWay}"
+                                   Clicked="OpaqueButton_Clicked" Foreground="Black"></controls:OpaqueButton>
+        </StackPanel>
+    </Grid>
+</UserControl>

Daybreak/Views/UpdateView.xaml.cs

@@ -0,0 +1,102 @@
+using Daybreak.Models;
+using Daybreak.Services.Logging;
+using Daybreak.Services.Updater;
+using Daybreak.Services.ViewManagement;
+using Daybreak.Utils;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Extensions;
+
+namespace Daybreak.Views
+{
+    /// <summary>
+    /// Interaction logic for UpdateView.xaml
+    /// </summary>
+    public partial class UpdateView : UserControl
+    {
+        public readonly static DependencyProperty DescriptionProperty =
+            DependencyPropertyExtensions.Register<UpdateView, string>(nameof(Description));
+        public readonly static DependencyProperty ProgressValueProperty =
+            DependencyPropertyExtensions.Register<UpdateView, double>(nameof(ProgressValue));
+        public readonly static DependencyProperty ContinueButtonEnabledProperty =
+            DependencyPropertyExtensions.Register<UpdateView, bool>(nameof(ContinueButtonEnabled));
+
+        private readonly ILogger logger;
+        private readonly IViewManager viewManager;
+        private readonly IApplicationUpdater applicationUpdater;
+        private readonly UpdateStatus updateStatus = new();
+
+        private bool success = false;
+
+        public string Description
+        {
+            get => this.GetTypedValue<string>(DescriptionProperty);
+            set => this.SetValue(DescriptionProperty, value);
+        }
+        public double ProgressValue
+        {
+            get => this.GetTypedValue<double>(ProgressValueProperty);
+            set => this.SetValue(ProgressValueProperty, value);
+        }
+        public bool ContinueButtonEnabled
+        {
+            get => this.GetTypedValue<bool>(ContinueButtonEnabledProperty);
+            set => this.SetValue(ContinueButtonEnabledProperty, value);
+        }
+
+        public UpdateView(
+            IApplicationUpdater applicationUpdater,
+            ILogger logger,
+            IViewManager viewManager)
+        {
+            this.applicationUpdater = applicationUpdater;
+            this.logger = logger;
+            this.viewManager = viewManager;
+            this.updateStatus.PropertyChanged += UpdateStatus_PropertyChanged;
+            this.InitializeComponent();
+        }
+
+        private void UpdateStatus_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            this.Dispatcher.Invoke(() =>
+            {
+                if (this.updateStatus.CurrentStep is UpdateStatus.DownloadUpdateStep downloadUpdateStep)
+                {
+                    this.ProgressValue = downloadUpdateStep.Progress * 100;
+                }
+
+                this.Description = this.updateStatus.CurrentStep.Name;
+            });
+        }
+
+        private async void UpdateView_Loaded(object sender, RoutedEventArgs e)
+        {
+            this.logger.LogInformation("Starting update procedure");
+            var success = await applicationUpdater.DownloadUpdate(updateStatus).ConfigureAwait(true);
+            if (success is false)
+            {
+                this.logger.LogError("Update procedure failed");
+            }
+            else
+            {
+                this.success= true;
+                this.logger.LogInformation("Downloaded update");
+            }
+
+            this.ContinueButtonEnabled = true;
+        }
+
+        private void OpaqueButton_Clicked(object sender, System.EventArgs e)
+        {
+            if (this.success)
+            {
+                this.applicationUpdater.FinalizeUpdate();
+                Application.Current.Shutdown();
+            }
+            else
+            {
+                this.viewManager.ShowView<MainView>();
+            }
+        }
+    }
+}

README.md

@@ -1,10 +1,26 @@
 # Daybreak
 Custom client for Guildwars.
-Requires standalone version https://developer.microsoft.com/microsoft-edge/webview2.
+Requires webview2 runtime https://go.microsoft.com/fwlink/p/?LinkId=2124703.
 
-![Alt Text](https://media1.giphy.com/media/Z32o0OZ5pZHDOIodzD/giphy.gif)
+![Showcase 1](https://media1.giphy.com/media/Z32o0OZ5pZHDOIodzD/giphy.gif)
+![Showcase 2](https://media0.giphy.com/media/aQ8Wl7lsuhT0AblCPI/giphy.gif)
+![Showcase 3](https://media2.giphy.com/media/s06PtxgeAAZtoJhTx6/giphy.gif)
 
-## Features
+# Examples/Usage
+To modify any settings, press the settings button on the titlebar
+![Settings button](https://i.imgur.com/0QSTvNF.png)
+
+When launching, if any of the required settings are not valid (missing username/password/character name), the launcher will open the settings page.
+![Settings page](https://i.imgur.com/Pzs8N6S.png)
+
+By default, the browser address bar is set to readonly. To allow any link to be typed in the address bar, change the "Address bar readonly" setting from settings page to "True".
+
+When in the main view, the browsers open the default/prefferred page. To change the prefferred page, navigate to it using one of the browsers and press the star button. The current loaded page will become the default for the selected browser.
+![Browser default selection](https://i.imgur.com/nDnyIIL.png)
+
+To display other images than the ones retrieved from "http://bloogum.net/guildwars", place images in the Screenshots folder, next to the Daybreak.exe executable. If the folder doesn't exist yet, either create it or run the launcher once so that it gets created automatically.
+
+# Features
 Automatically detect if guildwars is running or not. Includes the ability to launch guildwars from the client.
 
 Manages username and password combination.