Initial Commit

ItsBrank · ItsBrank · commit 9f2c109e3348 · 2025-06-04T14:36:59.000-04:00
diff --git a/Controls/CRChangelog.Designer.cs b/Controls/CRChangelog.Designer.cs
diff --git a/Controls/CRChangelog.cs b/Controls/CRChangelog.cs
@@ -181,7 +181,17 @@ private void TitleLbl_DoubleClick(object sender, EventArgs e)
             ToggleType();
         }
 
-        public void ToggleType()
+        private void DescriptionLbl_Click(object sender, EventArgs e)
+        {
+            ToggleType();
+        }
+
+        private void DescriptionLbl_DoubleClick(object sender, EventArgs e)
+        {
+            ToggleType();
+        }
+
+        private void ToggleType()
         {
             DisplayType = ((DisplayType == ChangelogViews.Module) ? ChangelogViews.Launcher : ChangelogViews.Module);
             UpdateTheme();
diff --git a/Controls/CRChangelog.resx b/Controls/CRChangelog.resx
@@ -1,7 +1,7 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!--
-    Microsoft ResX Schema 
+    Microsoft ResX Schema
 
     Version 2.0
 
@@ -48,7 +48,7 @@
     value   : The object must be serialized with
             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
             : and then encoded with base64 encoding.
-    
+
     mimetype: application/x-microsoft.net.object.soap.base64
     value   : The object must be serialized with
             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
diff --git a/Forms/MainFrm.cs b/Forms/MainFrm.cs
@@ -1206,26 +1206,28 @@ private async Task<bool> CheckForUpdates(bool bInvalidate, bool bShowPrompt)
 
         private async void InstallCodeRed(bool bManuallyChoose)
         {
-            Result pathReport = Installer.CreateInstallPath(bManuallyChoose);
+            Result pathResult = Installer.CreateInstallPath(bManuallyChoose);
 
-            if (pathReport.Succeeded)
+            if (pathResult.Succeeded)
             {
-                Result moduleReport = await Installer.DownloadModule();
+                Result moduleResult = await Installer.DownloadModule();
 
-                if (moduleReport.Succeeded)
+                if (moduleResult.Succeeded)
                 {
                     await CheckForUpdates(true, false);
                     StartupRoutine(true);
                     InstallPopup.HidePopup();
                 }
-                else if (moduleReport.HasFailReason())
+                else if (moduleResult.HasFailReason())
                 {
-                    MessageBox.Show(moduleReport.FailReason, Assembly.GetTitle());
+                    Logger.Write("(InstallCodeRed) Module fail: " + moduleResult.FailReason, LogLevel.Fatal);
+                    MessageBox.Show(moduleResult.FailReason, Assembly.GetTitle());
                 }
             }
-            else if (pathReport.HasFailReason())
+            else if (pathResult.HasFailReason())
             {
-                MessageBox.Show(pathReport.FailReason, Assembly.GetTitle());
+                Logger.Write("(InstallCodeRed) Path fail: " + pathResult.FailReason, LogLevel.Fatal);
+                MessageBox.Show(pathResult.FailReason, Assembly.GetTitle());
             }
 
             InstallPopup.ButtonsEnabled = true;
@@ -1283,20 +1285,20 @@ private async void UpdatePopup_ButtonClickAccept(object sender, EventArgs e)
 
             RemoteStorage.Invalidate();
             await RemoteStorage.CheckInitialized();
-            Result report = await Updater.InstallUpdates(UpdatePopup);
+
+            Result installResult = await Updater.InstallUpdates(UpdatePopup);
             UpdatePopup.ButtonsEnabled = true;
 
-            if (report.Succeeded)
+            if (installResult.Succeeded)
             {
                 NewsCtrl.ParseArticles(await RemoteStorage.GetNewsUrl());
                 UpdatePopup.HidePopup();
                 ProcessTmr.Start();
                 CheckForUpdates(true, false);
             }
-            else if (report.HasFailReason())
+            else if (installResult.HasFailReason())
             {
                 UpdatePopup.UpdateType = CRUpdate.UpdateLayouts.Fail;
-                Logger.Write("(UpdatePopup) " + report.FailReason, LogLevel.Error);
             }
         }
 
diff --git a/Framework/Installer.cs b/Framework/Installer.cs
@@ -40,7 +40,7 @@ public static void ModifyRegistry(bool bDeleteKey, Architecture.Path installPath
 
         public static Result CreateInstallPath(bool bManuallyChoose)
         {
-            Result report = new Result();
+            Result result = new Result();
             Architecture.Path installPath = new Architecture.Path();
 
             if (bManuallyChoose)
@@ -72,42 +72,42 @@ public static Result CreateInstallPath(bool bManuallyChoose)
             {
                 ModifyRegistry(false, installPath);
                 LocalStorage.Invalidate(true);
-                report.Succeeded = true;
+                result.Succeeded = true;
             }
             else
             {
-                report.FailReason = "Failed to locate desired install path.";
+                result.FailReason = "Failed to locate desired install path.";
             }
 
-            return report;
+            return result;
         }
 
         public static async Task<Result> DownloadModule()
         {
-            Result report = new Result();
+            Result result = new Result();
             Architecture.Path moduleFolder = LocalStorage.GetModulePath();
 
             if (moduleFolder.Exists())
             {
-                Result moduleReport = await Updater.ForceInstallModule(); // Doing a little cheaty cheat here, letting the updater do the rest of the work.
+                Result moduleResult = await Updater.ForceInstallModule(); // Doing a little cheaty cheat here, letting the updater do the rest of the work.
 
-                if (!moduleReport.Succeeded)
+                if (!moduleResult.Succeeded)
                 {
                     Configuration.CheckInitialized();
-                    Logger.Write("(DownloadModule) Failed to download module file: " + moduleReport.FailReason, LogLevel.Error);
-                    return moduleReport;
+                    Logger.Write("(DownloadModule) Failed to download module file: " + moduleResult.FailReason, LogLevel.Error);
+                    return moduleResult;
                 }
                 else
                 {
-                    report.Succeeded = true;
+                    result.Succeeded = true;
                 }
             }
             else
             {
-                report.FailReason = "Failed to locate folder, cannot download latest module archive!";
+                result.FailReason = "Failed to locate folder, cannot download latest module archive!";
             }
 
-            return report;
+            return result;
         }
     }
 }
diff --git a/Framework/Updater.cs b/Framework/Updater.cs
@@ -5,6 +5,7 @@
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using System.Collections.Generic;
+using Windows.System;
 
 namespace CodeRedLauncher
 {
@@ -121,13 +122,13 @@ public static async Task<bool> IsLauncherOutdated(bool bInvalidate)
         private static async Task<Result> InstallModule(bool bForceInstall)
         {
             SetStatus(UpdatorStatus.Preparing);
-            Result report = new Result();
+            Result result = new Result();
 
             if (!bForceInstall && !m_moduleOutdated)
             {
                 SetStatus(UpdatorStatus.Idle);
-                report.FailReason = "No module update required.";
-                return report;
+                result.FailReason = "No module update required.";
+                return result;
             }
 
             Architecture.Path tempFolder = (new Architecture.Path(Path.GetTempPath()) / "CodeRedLauncher");
@@ -208,26 +209,26 @@ private static async Task<Result> InstallModule(bool bForceInstall)
                             }
 
                             Logger.Write("(InstallModule) Done!");
-                            report.Succeeded = true;
+                            result.Succeeded = true;
                             m_moduleOutdated = false;
                             Configuration.SaveChanges();
                         }
                     }
                     else
                     {
-                        report.FailReason = "Failed to download module archive.";
+                        result.FailReason = "Failed to download module archive.";
                     }
                 }
                 else
                 {
-                    report.FailReason = "Failed to retrieve download link.";
+                    result.FailReason = "Failed to retrieve download link.";
                 }
 
                 Directory.Delete(tempFolder.GetPath(), true);
             }
 
             SetStatus(UpdatorStatus.Idle);
-            return report;
+            return result;
         }
 
         public static async Task<Result> ForceInstallModule()
@@ -238,13 +239,13 @@ public static async Task<Result> ForceInstallModule()
         private static async Task<Result> InstallLauncher(bool bForceInstall)
         {
             SetStatus(UpdatorStatus.Preparing);
-            Result report = new Result();
+            Result result = new Result();
 
             if (!bForceInstall && !m_launcherOutdated)
             {
                 SetStatus(UpdatorStatus.Idle);
-                report.FailReason = "No launcher update required.";
-                return report;
+                result.FailReason = "No launcher update required.";
+                return result;
             }
 
             Architecture.Path tempFolder = (new Architecture.Path(Path.GetTempPath()) / "CodeRedLauncher");
@@ -318,7 +319,7 @@ private static async Task<Result> InstallLauncher(bool bForceInstall)
                                         if (dropperExe.Exists())
                                         {
                                             Logger.Write("(InstallLauncher) Done!");
-                                            report.Succeeded = true;
+                                            result.Succeeded = true;
                                             m_launcherOutdated = false;
 
                                             // Since the launcher is "half portable", the user can place the exe wherever they want and move it around.
@@ -333,40 +334,40 @@ private static async Task<Result> InstallLauncher(bool bForceInstall)
                                         }
                                         else
                                         {
-                                            report.FailReason = "Failed to extract dropper executable from its archive.";
+                                            result.FailReason = "Failed to extract dropper executable from its archive.";
                                         }
                                     }
                                 }
                                 else
                                 {
-                                    report.FailReason = "Failed to download dropper archive.";
+                                    result.FailReason = "Failed to download dropper archive.";
                                 }
                             }
                             else
                             {
-                                report.FailReason = "Failed to extract launcher executable from its archive.";
+                                result.FailReason = "Failed to extract launcher executable from its archive.";
                             }
                         }
                         else
                         {
-                            report.FailReason = "Failed to download launcher archive.";
+                            result.FailReason = "Failed to download launcher archive.";
                         }
                     }
                     else
                     {
-                        report.FailReason = "Failed to download launcher executable.";
+                        result.FailReason = "Failed to download launcher executable.";
                     }
                 }
                 else
                 {
-                    report.FailReason = "Failed to retrieve download links.";
+                    result.FailReason = "Failed to retrieve download links.";
                 }
 
                 Directory.Delete(tempFolder.GetPath(), true);
             }
 
             SetStatus(UpdatorStatus.Idle);
-            return report;
+            return result;
         }
 
         public static async Task<Result> ForceInstallLauncher()
@@ -377,40 +378,41 @@ public static async Task<Result> ForceInstallLauncher()
         public static async Task<Result> InstallUpdates(Controls.CRUpdate updateCtrl)
         {
             m_updateCtrl = updateCtrl;
-            Result report = new Result();
+            Result result = new Result();
 
             if (!Configuration.OfflineMode.GetBoolValue())
             {
                 if (m_moduleOutdated)
                 {
-                    Result moduleReport = await InstallModule(false);
+                    Result moduleResult = await InstallModule(false);
 
-                    if (!moduleReport.Succeeded)
+                    if (!moduleResult.Succeeded)
                     {
-                        Logger.Write("(InstallUpdates) " + moduleReport.FailReason, LogLevel.Error);
-                        return moduleReport;
+                        Logger.Write("(InstallUpdates) " + moduleResult.FailReason, LogLevel.Error);
+                        return moduleResult;
                     }
                 }
 
                 if (m_launcherOutdated)
                 {
-                    Result launcherReport = await InstallLauncher(false);
+                    Result launcherResult = await InstallLauncher(false);
 
-                    if (!launcherReport.Succeeded)
+                    if (!launcherResult.Succeeded)
                     {
-                        Logger.Write("(InstallUpdates) " + launcherReport.FailReason, LogLevel.Error);
-                        return launcherReport;
+                        Logger.Write("(InstallUpdates) " + launcherResult.FailReason, LogLevel.Error);
+                        return launcherResult;
                     }
                 }
 
-                report.Succeeded = true;
+                result.Succeeded = true;
             }
             else
             {
-                report.FailReason = "Could not install updates, launcher is running in offline mode!";
+                result.FailReason = "Could not install updates, launcher is running in offline mode!";
+                Logger.Write("(InstallUpdates) " + result.FailReason, LogLevel.Error);
             }
 
-            return report;
+            return result;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1206,26 +1206,28 @@ private async Task<bool> CheckForUpdates(bool bInvalidate, bool bShowPrompt)`
`1206`	`1206`
`1207`	`1207`	`private async void InstallCodeRed(bool bManuallyChoose)`
`1208`	`1208`	`{`
`1209`		`- Result pathReport = Installer.CreateInstallPath(bManuallyChoose);`
	`1209`	`+ Result pathResult = Installer.CreateInstallPath(bManuallyChoose);`
`1210`	`1210`
`1211`		`- if (pathReport.Succeeded)`
	`1211`	`+ if (pathResult.Succeeded)`
`1212`	`1212`	`{`
`1213`		`- Result moduleReport = await Installer.DownloadModule();`
	`1213`	`+ Result moduleResult = await Installer.DownloadModule();`
`1214`	`1214`
`1215`		`- if (moduleReport.Succeeded)`
	`1215`	`+ if (moduleResult.Succeeded)`
`1216`	`1216`	`{`
`1217`	`1217`	`await CheckForUpdates(true, false);`
`1218`	`1218`	`StartupRoutine(true);`
`1219`	`1219`	`InstallPopup.HidePopup();`
`1220`	`1220`	`}`
`1221`		`- else if (moduleReport.HasFailReason())`
	`1221`	`+ else if (moduleResult.HasFailReason())`
`1222`	`1222`	`{`
`1223`		`- MessageBox.Show(moduleReport.FailReason, Assembly.GetTitle());`
	`1223`	`+ Logger.Write("(InstallCodeRed) Module fail: " + moduleResult.FailReason, LogLevel.Fatal);`
	`1224`	`+ MessageBox.Show(moduleResult.FailReason, Assembly.GetTitle());`
`1224`	`1225`	`}`
`1225`	`1226`	`}`
`1226`		`- else if (pathReport.HasFailReason())`
	`1227`	`+ else if (pathResult.HasFailReason())`
`1227`	`1228`	`{`
`1228`		`- MessageBox.Show(pathReport.FailReason, Assembly.GetTitle());`
	`1229`	`+ Logger.Write("(InstallCodeRed) Path fail: " + pathResult.FailReason, LogLevel.Fatal);`
	`1230`	`+ MessageBox.Show(pathResult.FailReason, Assembly.GetTitle());`
`1229`	`1231`	`}`
`1230`	`1232`
`1231`	`1233`	`InstallPopup.ButtonsEnabled = true;`
`@@ -1283,20 +1285,20 @@ private async void UpdatePopup_ButtonClickAccept(object sender, EventArgs e)`
`1283`	`1285`
`1284`	`1286`	`RemoteStorage.Invalidate();`
`1285`	`1287`	`await RemoteStorage.CheckInitialized();`
`1286`		`- Result report = await Updater.InstallUpdates(UpdatePopup);`
	`1288`	`+`
	`1289`	`+ Result installResult = await Updater.InstallUpdates(UpdatePopup);`
`1287`	`1290`	`UpdatePopup.ButtonsEnabled = true;`
`1288`	`1291`
`1289`		`- if (report.Succeeded)`
	`1292`	`+ if (installResult.Succeeded)`
`1290`	`1293`	`{`
`1291`	`1294`	`NewsCtrl.ParseArticles(await RemoteStorage.GetNewsUrl());`
`1292`	`1295`	`UpdatePopup.HidePopup();`
`1293`	`1296`	`ProcessTmr.Start();`
`1294`	`1297`	`CheckForUpdates(true, false);`
`1295`	`1298`	`}`
`1296`		`- else if (report.HasFailReason())`
	`1299`	`+ else if (installResult.HasFailReason())`
`1297`	`1300`	`{`
`1298`	`1301`	`UpdatePopup.UpdateType = CRUpdate.UpdateLayouts.Fail;`
`1299`		`- Logger.Write("(UpdatePopup) " + report.FailReason, LogLevel.Error);`
`1300`	`1302`	`}`
`1301`	`1303`	`}`
`1302`	`1304`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public static void ModifyRegistry(bool bDeleteKey, Architecture.Path installPath`
`40`	`40`
`41`	`41`	`public static Result CreateInstallPath(bool bManuallyChoose)`
`42`	`42`	`{`
`43`		`- Result report = new Result();`
	`43`	`+ Result result = new Result();`
`44`	`44`	`Architecture.Path installPath = new Architecture.Path();`
`45`	`45`
`46`	`46`	`if (bManuallyChoose)`
`@@ -72,42 +72,42 @@ public static Result CreateInstallPath(bool bManuallyChoose)`
`72`	`72`	`{`
`73`	`73`	`ModifyRegistry(false, installPath);`
`74`	`74`	`LocalStorage.Invalidate(true);`
`75`		`- report.Succeeded = true;`
	`75`	`+ result.Succeeded = true;`
`76`	`76`	`}`
`77`	`77`	`else`
`78`	`78`	`{`
`79`		`- report.FailReason = "Failed to locate desired install path.";`
	`79`	`+ result.FailReason = "Failed to locate desired install path.";`
`80`	`80`	`}`
`81`	`81`
`82`		`- return report;`
	`82`	`+ return result;`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`public static async Task<Result> DownloadModule()`
`86`	`86`	`{`
`87`		`- Result report = new Result();`
	`87`	`+ Result result = new Result();`
`88`	`88`	`Architecture.Path moduleFolder = LocalStorage.GetModulePath();`
`89`	`89`
`90`	`90`	`if (moduleFolder.Exists())`
`91`	`91`	`{`
`92`		`- Result moduleReport = await Updater.ForceInstallModule(); // Doing a little cheaty cheat here, letting the updater do the rest of the work.`
	`92`	`+ Result moduleResult = await Updater.ForceInstallModule(); // Doing a little cheaty cheat here, letting the updater do the rest of the work.`
`93`	`93`
`94`		`- if (!moduleReport.Succeeded)`
	`94`	`+ if (!moduleResult.Succeeded)`
`95`	`95`	`{`
`96`	`96`	`Configuration.CheckInitialized();`
`97`		`- Logger.Write("(DownloadModule) Failed to download module file: " + moduleReport.FailReason, LogLevel.Error);`
`98`		`- return moduleReport;`
	`97`	`+ Logger.Write("(DownloadModule) Failed to download module file: " + moduleResult.FailReason, LogLevel.Error);`
	`98`	`+ return moduleResult;`
`99`	`99`	`}`
`100`	`100`	`else`
`101`	`101`	`{`
`102`		`- report.Succeeded = true;`
	`102`	`+ result.Succeeded = true;`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`else`
`106`	`106`	`{`
`107`		`- report.FailReason = "Failed to locate folder, cannot download latest module archive!";`
	`107`	`+ result.FailReason = "Failed to locate folder, cannot download latest module archive!";`
`108`	`108`	`}`
`109`	`109`
`110`		`- return report;`
	`110`	`+ return result;`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using System.Threading.Tasks;`
`6`	`6`	`using System.Windows.Forms;`
`7`	`7`	`using System.Collections.Generic;`
	`8`	`+using Windows.System;`
`8`	`9`
`9`	`10`	`namespace CodeRedLauncher`
`10`	`11`	`{`
`@@ -121,13 +122,13 @@ public static async Task<bool> IsLauncherOutdated(bool bInvalidate)`
`121`	`122`	`private static async Task<Result> InstallModule(bool bForceInstall)`
`122`	`123`	`{`
`123`	`124`	`SetStatus(UpdatorStatus.Preparing);`
`124`		`- Result report = new Result();`
	`125`	`+ Result result = new Result();`
`125`	`126`
`126`	`127`	`if (!bForceInstall && !m_moduleOutdated)`
`127`	`128`	`{`
`128`	`129`	`SetStatus(UpdatorStatus.Idle);`
`129`		`- report.FailReason = "No module update required.";`
`130`		`- return report;`
	`130`	`+ result.FailReason = "No module update required.";`
	`131`	`+ return result;`
`131`	`132`	`}`
`132`	`133`
`133`	`134`	`Architecture.Path tempFolder = (new Architecture.Path(Path.GetTempPath()) / "CodeRedLauncher");`
`@@ -208,26 +209,26 @@ private static async Task<Result> InstallModule(bool bForceInstall)`
`208`	`209`	`}`
`209`	`210`
`210`	`211`	`Logger.Write("(InstallModule) Done!");`
`211`		`- report.Succeeded = true;`
	`212`	`+ result.Succeeded = true;`
`212`	`213`	`m_moduleOutdated = false;`
`213`	`214`	`Configuration.SaveChanges();`
`214`	`215`	`}`
`215`	`216`	`}`
`216`	`217`	`else`
`217`	`218`	`{`
`218`		`- report.FailReason = "Failed to download module archive.";`
	`219`	`+ result.FailReason = "Failed to download module archive.";`
`219`	`220`	`}`
`220`	`221`	`}`
`221`	`222`	`else`
`222`	`223`	`{`
`223`		`- report.FailReason = "Failed to retrieve download link.";`
	`224`	`+ result.FailReason = "Failed to retrieve download link.";`
`224`	`225`	`}`
`225`	`226`
`226`	`227`	`Directory.Delete(tempFolder.GetPath(), true);`
`227`	`228`	`}`
`228`	`229`
`229`	`230`	`SetStatus(UpdatorStatus.Idle);`
`230`		`- return report;`
	`231`	`+ return result;`
`231`	`232`	`}`
`232`	`233`
`233`	`234`	`public static async Task<Result> ForceInstallModule()`
`@@ -238,13 +239,13 @@ public static async Task<Result> ForceInstallModule()`
`238`	`239`	`private static async Task<Result> InstallLauncher(bool bForceInstall)`
`239`	`240`	`{`
`240`	`241`	`SetStatus(UpdatorStatus.Preparing);`
`241`		`- Result report = new Result();`
	`242`	`+ Result result = new Result();`
`242`	`243`
`243`	`244`	`if (!bForceInstall && !m_launcherOutdated)`
`244`	`245`	`{`
`245`	`246`	`SetStatus(UpdatorStatus.Idle);`
`246`		`- report.FailReason = "No launcher update required.";`
`247`		`- return report;`
	`247`	`+ result.FailReason = "No launcher update required.";`
	`248`	`+ return result;`
`248`	`249`	`}`
`249`	`250`
`250`	`251`	`Architecture.Path tempFolder = (new Architecture.Path(Path.GetTempPath()) / "CodeRedLauncher");`
`@@ -318,7 +319,7 @@ private static async Task<Result> InstallLauncher(bool bForceInstall)`
`318`	`319`	`if (dropperExe.Exists())`
`319`	`320`	`{`
`320`	`321`	`Logger.Write("(InstallLauncher) Done!");`
`321`		`- report.Succeeded = true;`
	`322`	`+ result.Succeeded = true;`
`322`	`323`	`m_launcherOutdated = false;`
`323`	`324`
`324`	`325`	`// Since the launcher is "half portable", the user can place the exe wherever they want and move it around.`
`@@ -333,40 +334,40 @@ private static async Task<Result> InstallLauncher(bool bForceInstall)`
`333`	`334`	`}`
`334`	`335`	`else`
`335`	`336`	`{`
`336`		`- report.FailReason = "Failed to extract dropper executable from its archive.";`
	`337`	`+ result.FailReason = "Failed to extract dropper executable from its archive.";`
`337`	`338`	`}`
`338`	`339`	`}`
`339`	`340`	`}`
`340`	`341`	`else`
`341`	`342`	`{`
`342`		`- report.FailReason = "Failed to download dropper archive.";`
	`343`	`+ result.FailReason = "Failed to download dropper archive.";`
`343`	`344`	`}`
`344`	`345`	`}`
`345`	`346`	`else`
`346`	`347`	`{`
`347`		`- report.FailReason = "Failed to extract launcher executable from its archive.";`
	`348`	`+ result.FailReason = "Failed to extract launcher executable from its archive.";`
`348`	`349`	`}`
`349`	`350`	`}`
`350`	`351`	`else`
`351`	`352`	`{`
`352`		`- report.FailReason = "Failed to download launcher archive.";`
	`353`	`+ result.FailReason = "Failed to download launcher archive.";`
`353`	`354`	`}`
`354`	`355`	`}`
`355`	`356`	`else`
`356`	`357`	`{`
`357`		`- report.FailReason = "Failed to download launcher executable.";`
	`358`	`+ result.FailReason = "Failed to download launcher executable.";`
`358`	`359`	`}`
`359`	`360`	`}`
`360`	`361`	`else`
`361`	`362`	`{`
`362`		`- report.FailReason = "Failed to retrieve download links.";`
	`363`	`+ result.FailReason = "Failed to retrieve download links.";`
`363`	`364`	`}`
`364`	`365`
`365`	`366`	`Directory.Delete(tempFolder.GetPath(), true);`
`366`	`367`	`}`
`367`	`368`
`368`	`369`	`SetStatus(UpdatorStatus.Idle);`
`369`		`- return report;`
	`370`	`+ return result;`
`370`	`371`	`}`
`371`	`372`
`372`	`373`	`public static async Task<Result> ForceInstallLauncher()`
`@@ -377,40 +378,41 @@ public static async Task<Result> ForceInstallLauncher()`
`377`	`378`	`public static async Task<Result> InstallUpdates(Controls.CRUpdate updateCtrl)`
`378`	`379`	`{`
`379`	`380`	`m_updateCtrl = updateCtrl;`
`380`		`- Result report = new Result();`
	`381`	`+ Result result = new Result();`
`381`	`382`
`382`	`383`	`if (!Configuration.OfflineMode.GetBoolValue())`
`383`	`384`	`{`
`384`	`385`	`if (m_moduleOutdated)`
`385`	`386`	`{`
`386`		`- Result moduleReport = await InstallModule(false);`
	`387`	`+ Result moduleResult = await InstallModule(false);`
`387`	`388`
`388`		`- if (!moduleReport.Succeeded)`
	`389`	`+ if (!moduleResult.Succeeded)`
`389`	`390`	`{`
`390`		`- Logger.Write("(InstallUpdates) " + moduleReport.FailReason, LogLevel.Error);`
`391`		`- return moduleReport;`
	`391`	`+ Logger.Write("(InstallUpdates) " + moduleResult.FailReason, LogLevel.Error);`
	`392`	`+ return moduleResult;`
`392`	`393`	`}`
`393`	`394`	`}`
`394`	`395`
`395`	`396`	`if (m_launcherOutdated)`
`396`	`397`	`{`
`397`		`- Result launcherReport = await InstallLauncher(false);`
	`398`	`+ Result launcherResult = await InstallLauncher(false);`
`398`	`399`
`399`		`- if (!launcherReport.Succeeded)`
	`400`	`+ if (!launcherResult.Succeeded)`
`400`	`401`	`{`
`401`		`- Logger.Write("(InstallUpdates) " + launcherReport.FailReason, LogLevel.Error);`
`402`		`- return launcherReport;`
	`402`	`+ Logger.Write("(InstallUpdates) " + launcherResult.FailReason, LogLevel.Error);`
	`403`	`+ return launcherResult;`
`403`	`404`	`}`
`404`	`405`	`}`
`405`	`406`
`406`		`- report.Succeeded = true;`
	`407`	`+ result.Succeeded = true;`
`407`	`408`	`}`
`408`	`409`	`else`
`409`	`410`	`{`
`410`		`- report.FailReason = "Could not install updates, launcher is running in offline mode!";`
	`411`	`+ result.FailReason = "Could not install updates, launcher is running in offline mode!";`
	`412`	`+ Logger.Write("(InstallUpdates) " + result.FailReason, LogLevel.Error);`
`411`	`413`	`}`
`412`	`414`
`413`		`- return report;`
	`415`	`+ return result;`
`414`	`416`	`}`
`415`	`417`	`}`
`416`	`418`	`}`