public static async void UpdateSteamInstallationPathAsync()
{
try
{
if (string.IsNullOrEmpty(Properties.Settings.Default.steamInstallationPath) || !Directory.Exists(Properties.Settings.Default.steamInstallationPath))
{
Properties.Settings.Default.steamInstallationPath = Registry.GetValue(Definitions.Global.Steam.RegistryKeyPath, "SteamPath", "").ToString().Replace('/', Path.DirectorySeparatorChar);
if (string.IsNullOrEmpty(Properties.Settings.Default.steamInstallationPath))
{
if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.Steam_NotInstalled)), SLM.Translate(Properties.Resources.Steam_NotInstalledMessage), MessageDialogStyle.AffirmativeAndNegative).ConfigureAwait(true) == MessageDialogResult.Affirmative)
{
var steamPathSelector = new OpenFileDialog()
{
Filter = "Steam Executable (Steam.exe)|Steam.exe"
};
if (steamPathSelector.ShowDialog() == true)
{
if (Directory.Exists(Path.GetDirectoryName(steamPathSelector.FileName)))
{
Properties.Settings.Default.steamInstallationPath = Path.GetDirectoryName(steamPathSelector.FileName);
}
}
}
}
if (!string.IsNullOrEmpty(Properties.Settings.Default.steamInstallationPath))
{
Definitions.Global.Steam.vdfFilePath = Path.Combine(Properties.Settings.Default.steamInstallationPath, "config", "config.vdf");
}
}
}
catch (NullReferenceException ex)
{
logger.Error(ex);
}
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public static bool UnloadLibrary(LibraryType targetLibraryType)
{
try
{
switch (targetLibraryType)
{
case LibraryType.Steam:
case LibraryType.SLM:
if (Definitions.Global.Steam.IsStateChanging)
{
return(false);
}
else
{
Definitions.Global.Steam.IsStateChanging = true;
Definitions.Global.Steam.Loaded = false;
}
break;
case LibraryType.Origin:
if (Definitions.Global.Origin.IsStateChanging)
{
return(false);
}
else
{
Definitions.Global.Origin.IsStateChanging = true;
Definitions.Global.Origin.Loaded = false;
}
break;
case LibraryType.Uplay:
if (Definitions.Global.Uplay.IsStateChanging)
{
return(false);
}
else
{
Definitions.Global.Uplay.IsStateChanging = true;
Definitions.Global.Uplay.Loaded = false;
}
break;
}
if (TaskManager.TaskList.Count(x => (x.App.Library.Type == targetLibraryType || x.TargetLibrary.Type == targetLibraryType) && !x.Completed) > 0)
{
Logger.Warn(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.CantUnloadLibraryWithActiveTask)), new { targetLibraryType }));
ToggleOffLibrarySwitchState(targetLibraryType);
return(false);
}
// Library Context Menu Items
foreach (var menuItem in Definitions.List.LibraryCMenuItems.Where(x => x.AllowedLibraryTypes.Contains(targetLibraryType)).ToList())
{
Definitions.List.LibraryCMenuItems.Remove(menuItem);
}
// App Context Menu Items
foreach (var menuItem in Definitions.List.AppCMenuItems.Where(x => x.AllowedLibraryTypes.Contains(targetLibraryType)).ToList())
{
Definitions.List.AppCMenuItems.Remove(menuItem);
}
foreach (var library in Definitions.List.Libraries.Where(x => x.Type == targetLibraryType).ToList())
{
if (Definitions.SLM.CurrentSelectedLibrary == library)
{
Definitions.SLM.CurrentSelectedLibrary = null;
Main.FormAccessor.AppView.AppPanel.ItemsSource = null;
}
Definitions.List.Libraries.Remove(library);
}
ToggleOffLibrarySwitchState(targetLibraryType);
return(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
Logger.Fatal(ex);
ToggleOffLibrarySwitchState(targetLibraryType);
return(false);
}
}
public static void PopulateAppCMenuItems()
{
#region App Context Menu Item Definitions
// Run
var menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Play)),
Action = "steam://run/{0}",
Icon = FontAwesome.WPF.FontAwesomeIcon.Play,
ShowToSteamBackup = false,
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true,
ShowToSteamBackup = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compress
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Compress)),
Action = "Compress",
ShowToCompressed = true,
ShowToSteamBackup = false,
Icon = FontAwesome.WPF.FontAwesomeIcon.FileZipOutline
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compact
menuItem = new Definitions.ContextMenuItem
{
Header = "Compact",
Action = "compact",
ShowToCompressed = false,
ShowToSteamBackup = false,
Icon = FontAwesome.WPF.FontAwesomeIcon.FileArchiveOutline
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true,
ShowToSteamBackup = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Show on disk
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DiskInfo)),
Action = "Disk",
ShowToCompressed = true,
Icon = FontAwesome.WPF.FontAwesomeIcon.FolderOpen
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// View ACF
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_ViewACF)),
Action = "acffile",
Icon = FontAwesome.WPF.FontAwesomeIcon.PencilSquareOutline,
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Game hub
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_GameHub)),
Action = "steam://url/GameHub/{0}",
Icon = FontAwesome.WPF.FontAwesomeIcon.Book
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Workshop
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Workshop)),
Action = "steam://url/SteamWorkshopPage/{0}",
Icon = FontAwesome.WPF.FontAwesomeIcon.Cog
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Subscribed Workshop Items
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_SubscribedWorkshopItems)),
Action = "https://steamcommunity.com/profiles/{1}/myworkshopfiles/?appid={0}&browsefilter=mysubscriptions&sortmethod=lastupdated",
Icon = FontAwesome.WPF.FontAwesomeIcon.Cogs
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using Task Manager)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DeleteFilesSLM)),
Action = "deleteappfiles",
Icon = FontAwesome.WPF.FontAwesomeIcon.TrashOutline
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using Task Manager)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DeleteFilesTM)),
Action = "deleteappfilestm",
Icon = FontAwesome.WPF.FontAwesomeIcon.Trash
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
#endregion App Context Menu Item Definitions
}
public static async Task RemoveGivenFilesAsync(IEnumerable <string> FileList, List <string> DirectoryList = null, Definitions.List.TaskInfo CurrentTask = null)
{
try
{
if (CurrentTask != null)
{
await Task.Delay(5000);
}
Parallel.ForEach(FileList, currentFile =>
{
FileInfo File = new FileInfo(currentFile);
if (File.Exists)
{
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskStatus_DeletingFile)), new { FileName = File.Name, FormattedFileSize = FormatBytes(File.Length) });
}
Alphaleonis.Win32.Filesystem.File.SetAttributes(File.FullName, FileAttributes.Normal);
File.Delete();
}
});
if (DirectoryList != null)
{
Parallel.ForEach(DirectoryList, currentDirectory =>
{
DirectoryInfo Directory = new DirectoryInfo(currentDirectory);
if (Directory.Exists)
{
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskStatus_DeletingDirectory)), new { DirectoryName = Directory.Name });
}
Directory.Delete();
}
});
}
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = "";
}
}
catch (DirectoryNotFoundException ex)
{
logger.Error(ex);
}
catch (IOException ex)
{
logger.Error(ex);
}
catch (AggregateException ex)
{
logger.Error(ex);
}
catch (UnauthorizedAccessException ex)
{
logger.Error(ex);
}
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public static void PopulateAppCMenuItems()
{
#region App Context Menu Item Definitions
// Run
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_Run)),
Action = "steam://run/{0}", // TO-DO
Icon = FontAwesome.WPF.FontAwesomeIcon.Play,
LibraryType = Definitions.Enums.LibraryType.Origin,
ShowToCompressed = false
});
// Compact
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = "Compact",
Action = "compact",
LibraryType = Definitions.Enums.LibraryType.Origin,
ShowToCompressed = false,
Icon = FontAwesome.WPF.FontAwesomeIcon.FileArchiveOutline
});
// Separator
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
ShowToCompressed = false,
LibraryType = Definitions.Enums.LibraryType.Origin,
IsSeparator = true
});
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_Install)),
Action = "install",
Icon = FontAwesome.WPF.FontAwesomeIcon.Gear,
LibraryType = Definitions.Enums.LibraryType.Origin,
ShowToCompressed = false
});
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_Repair)),
Action = "repair",
Icon = FontAwesome.WPF.FontAwesomeIcon.Gears,
LibraryType = Definitions.Enums.LibraryType.Origin,
ShowToCompressed = false
});
// Separator
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
ShowToCompressed = false,
LibraryType = Definitions.Enums.LibraryType.Origin,
IsSeparator = true
});
// Show on disk
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_DiskInfo)),
Action = "Disk",
LibraryType = Definitions.Enums.LibraryType.Origin,
Icon = FontAwesome.WPF.FontAwesomeIcon.FolderOpen
});
// Separator
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
IsSeparator = true,
LibraryType = Definitions.Enums.LibraryType.Origin
});
// Delete files (using SLM)
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_DeleteFilesSLM)),
Action = "deleteappfiles",
LibraryType = Definitions.Enums.LibraryType.Origin,
Icon = FontAwesome.WPF.FontAwesomeIcon.TrashOutline
});
// Delete files (using Task Manager)
Definitions.List.AppCMenuItems.Add(new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_DeleteFilesTM)),
Action = "deleteappfilestm",
LibraryType = Definitions.Enums.LibraryType.Origin,
Icon = FontAwesome.WPF.FontAwesomeIcon.Trash
});
#endregion App Context Menu Item Definitions
}
public static async void CreateNew(string NewLibraryPath, bool Backup)
{
try
{
if (string.IsNullOrEmpty(NewLibraryPath))
{
return;
}
// If we are not creating a backup library
if (!Backup)
{
await CloseSteamAsync().ConfigureAwait(true);
// Define steam dll paths for better looking
string SteamDLLPath = Path.Combine(NewLibraryPath, "Steam.dll");
if (!File.Exists(SteamDLLPath))
{
// Copy Steam.dll as steam needs it
File.Copy(Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.dll"), SteamDLLPath, true);
}
if (!Directory.Exists(Path.Combine(NewLibraryPath, "SteamApps")))
{
// create SteamApps directory at requested directory
Directory.CreateDirectory(Path.Combine(NewLibraryPath, "SteamApps"));
}
// If Steam.dll moved succesfully
if (File.Exists(SteamDLLPath)) // in case of permissions denied
{
// Call KeyValue in act
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file as text
Key.ReadFileAsText(Definitions.Global.Steam.vdfFilePath);
// Add our new library to vdf file so steam will know we have a new library
Key["Software"]["Valve"]["Steam"].Children.Add(new Framework.KeyValue(string.Format("BaseInstallFolder_{0}", Definitions.List.Libraries.Select(x => x.Type == Definitions.Enums.LibraryType.Steam).Count()), NewLibraryPath));
// Save vdf file
Key.SaveToFile(Definitions.Global.Steam.vdfFilePath, false);
// Show a messagebox to user about process
MessageBox.Show(SLM.Translate(nameof(Properties.Resources.CreateSteamLibrary_Created)));
// Since this file started to interrupt us?
// No need to bother with it since config.vdf is the real deal, just remove it and Steam client will handle.
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf")))
{
File.Delete(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf"));
}
RestartSteamAsync();
}
else
{
// Show an error to user and cancel the process because we couldn't get Steam.dll in new library dir
MessageBox.Show(SLM.Translate(nameof(Properties.Resources.CreateSteamLibrary_UnknownError)));
}
}
// Add library to list
AddNew(NewLibraryPath);
// Save our settings
SLM.Settings.SaveSettings();
}
catch (UnauthorizedAccessException ex)
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.CreateSteamLibrary_UnauthorizedAccessException)), Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.CreateSteamLibrary_UnauthorizedAccessExceptionMessage)), new { NewLibraryPath, ExceptionMessage = ex.Message }), MessageDialogStyle.AffirmativeAndNegative).ConfigureAwait(true);
}, System.Windows.Threading.DispatcherPriority.Normal).ConfigureAwait(true);
logger.Fatal(ex);
}
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public static void PopulateLibraryCMenuItems()
{
#region Library Context Menu Item Definitions
// Open library in explorer ({0})
var menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_Open)),
Action = "Disk",
Icon = FontAwesome.WPF.FontAwesomeIcon.FolderOpen,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Remove library & files
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_RemoveFromSteam)),
Action = "deleteLibrary",
Icon = FontAwesome.WPF.FontAwesomeIcon.Trash,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Delete games in library
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_DeleteGames)),
Action = "deleteLibrarySLM",
Icon = FontAwesome.WPF.FontAwesomeIcon.TrashOutline,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
ShowToNormal = false,
ShowToOffline = false,
ShowToSLMBackup = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Remove from SLM
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_RemoveFromSLM)),
Action = "RemoveFromList",
Icon = FontAwesome.WPF.FontAwesomeIcon.Minus,
ShowToSLMBackup = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
#endregion Library Context Menu Item Definitions
}
public static async void ReadDetailsFromZip(string ZipPath, Definitions.Library targetLibrary)
{
try
{
// Open archive for read
using (ZipArchive Archive = ZipFile.OpenRead(ZipPath))
{
if (Archive.Entries.Count > 0)
{
// For each file in opened archive
foreach (ZipArchiveEntry AcfEntry in Archive.Entries.Where(x => x.Name.Contains("appmanifest_")))
{
// If it contains
// Define a KeyValue reader
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// Open .acf file from archive as text
KeyValReader.ReadAsText(AcfEntry.Open());
// If acf file has no children, skip this archive
if (KeyValReader.Children.Count == 0)
{
continue;
}
AddSteamApp(Convert.ToInt32(KeyValReader["appID"].Value), !string.IsNullOrEmpty(KeyValReader["name"].Value) ? KeyValReader["name"].Value : KeyValReader["UserConfig"]["name"].Value, KeyValReader["installdir"].Value, targetLibrary, Convert.ToInt64(KeyValReader["SizeOnDisk"].Value), Convert.ToInt64(KeyValReader["LastUpdated"].Value), true);
}
}
}
}
catch (IOException IEx)
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.ReadZip_IOException)), Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.ReadZip_IOExceptionMessage)), new { ZipPath }), MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings
{
NegativeButtonText = SLM.Translate(Properties.Resources.ReadZip_DontDelete)
}) == MessageDialogResult.Affirmative)
{
File.Delete(ZipPath);
}
});
System.Diagnostics.Debug.WriteLine(IEx);
logger.Fatal(IEx);
}
catch (InvalidDataException IEx)
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.ReadZip_InvalidDataException)), Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.ReadZip_InvalidDataExceptionMessage)), new { ZipPath }), MessageDialogStyle.AffirmativeAndNegative, new MetroDialogSettings
{
NegativeButtonText = SLM.Translate(Properties.Resources.ReadZip_DontDelete)
}) == MessageDialogResult.Affirmative)
{
File.Delete(ZipPath);
}
});
System.Diagnostics.Debug.WriteLine(IEx);
logger.Fatal(IEx);
}
catch (Exception ex)
{
Definitions.SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
logger.Fatal(ex);
}
}
public static void Pause()
{
try
{
if (Status && ActiveTask != null)
{
Main.FormAccessor.TaskManagerView.Button_StartTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_StartTaskManager.IsEnabled = true;
});
Main.FormAccessor.TaskManagerView.Button_PauseTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_PauseTaskManager.IsEnabled = false;
});
Main.FormAccessor.TaskManagerView.Button_StopTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_StopTaskManager.IsEnabled = true;
});
Paused = true;
ActiveTask.mre.Reset();
Main.FormAccessor.TaskManager_Logs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_Paused)), new { CurrentTime = DateTime.Now }));
}
}
catch (Exception ex)
{
Logger.Fatal(ex);
}
}
public static async Task ParseAppDetailsAsync(Stream fileStream, string installerFilePath, Definitions.OriginLibrary library, bool isCompressed = false)
{
try
{
if (!isCompressed && new FileInfo(installerFilePath).Directory.Parent.Parent.Name != new DirectoryInfo(library.FullPath).Name)
{
return;
}
var installerLog = Path.Combine(Directory.GetParent(installerFilePath).FullName, "InstallLog.txt");
var installedLocale = "en_US";
if (!isCompressed && File.Exists(installerLog))
{
foreach (var line in File.ReadAllLines(installerLog))
{
if (!line.Contains("Install Locale:"))
{
continue;
}
installedLocale = line.Split(new string[] { "Install Locale:" },
StringSplitOptions.None)[1];
break;
}
installedLocale = installedLocale.Replace(" ", "");
}
var xml = XDocument.Load(fileStream);
var manifestVersion = new Version((xml.Root.Name.LocalName == "game")
? xml.Root.Attribute("manifestVersion").Value
: ((xml.Root.Name.LocalName == "DiPManifest")
? xml.Root.Attribute("version").Value
: "1.0"));
Definitions.OriginAppInfo originAppInfo = null;
if (manifestVersion == new Version("4.0"))
{
originAppInfo = new Definitions.OriginAppInfo(library,
xml.Root.Element("gameTitles")?.Elements("gameTitle")
?.First(x => x.Attribute("locale").Value == "en_US")?.Value,
Convert.ToInt32(xml.Root.Element("contentIDs")?.Elements()
.FirstOrDefault(x => int.TryParse(x.Value, out int appId))?.Value),
(isCompressed) ? new FileInfo(installerFilePath).Directory : new FileInfo(installerFilePath).Directory.Parent,
new Version(xml.Root.Element("buildMetaData")?.Element("gameVersion")
?.Attribute("version")?.Value),
xml.Root.Element("installMetaData")?.Element("locales")?.Value.Split(','),
installedLocale,
isCompressed,
xml.Root.Element("touchup")?.Element("filePath")?.Value,
xml.Root.Element("touchup")?.Element("parameters")?.Value,
xml.Root.Element("touchup")?.Element("updateParameters")?.Value,
xml.Root.Element("touchup")?.Element("repairParameters")?.Value);
}
else if (manifestVersion >= new Version("1.1") && manifestVersion <= new Version("3.0"))
{
var locales = new List <string>();
foreach (var locale in xml.Root.Element("metadata")?.Elements("localeInfo")
?.Attributes()?.Where(x => x.Name == "locale"))
{
locales.Add(locale.Value);
}
originAppInfo = new Definitions.OriginAppInfo(library,
xml.Root.Element("metadata")?.Elements("localeInfo")
?.First(x => x.Attribute("locale").Value == "en_US")?.Element("title").Value,
Convert.ToInt32(xml.Root.Element("contentIDs")?.Element("contentID")?.Value
.Replace("EAX", "")),
(isCompressed) ? new FileInfo(installerFilePath).Directory : new FileInfo(installerFilePath).Directory.Parent,
new Version(xml.Root.Attribute("gameVersion").Value),
locales.ToArray(),
installedLocale,
isCompressed,
xml.Root.Element("executable")?.Element("filePath")?.Value,
xml.Root.Element("executable")?.Element("parameters")?.Value);
}
else
{
MessageBox.Show(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.OriginUnknownManifestFile)), new { ManifestVersion = manifestVersion, OriginApp = installerFilePath }));
return;
}
if (Definitions.Global.Origin.AppIds.Count(x => x.Key == originAppInfo.InstallationDirectory.Name) > 0)
{
var appId = Definitions.Global.Origin.AppIds.First(x => x.Key == originAppInfo.InstallationDirectory.Name);
var appLocalData = library.GetGameLocalData(appId.Value);
if (appLocalData != null)
{
await Framework.CachedImage.FileCache.HitAsync(string.Concat(appLocalData["customAttributes"]["imageServer"],
appLocalData["localizableAttributes"]["packArtLarge"])
, $"{originAppInfo.AppId}_o")
.ConfigureAwait(false);
}
}
originAppInfo.GameHeaderImage = $"{Definitions.Directories.SLM.Cache}\\{originAppInfo.AppId}_o.jpg";
library.Apps.Add(originAppInfo);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Logger.Error(ex);
}
}
public static void PopulateAppCMenuItems()
{
#region App Context Menu Item Definitions
// Run
var menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.Run)),
Action = "steam://run/{0}", // TO-DO
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Play, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compress
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.Compress)),
Action = "compress",
Icon = new PackIconOcticons()
{
Kind = PackIconOcticonsKind.FileZip, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compact
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.Compact)),
Action = "compact",
ShowToCompressed = false,
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.ArrowCollapse, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Install
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.Install)),
Action = "install",
Icon = new PackIconEntypo()
{
Kind = PackIconEntypoKind.Install, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Repair
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.OriginApp_CMenu_Repair)),
Action = "repair",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FileCheck, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Show on disk
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.MenuDiskInfo)),
Action = "Disk",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FolderOpen, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using SLM)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.DeleteFilesUsingSlm)),
Action = "deleteappfiles",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Delete, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using Task Manager)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.DeleteFilesUsingTaskmanager)),
Action = "deleteappfilestm",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.DeleteSweep, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Origin);
Definitions.List.AppCMenuItems.Add(menuItem);
#endregion App Context Menu Item Definitions
}
public static async Task GenerateLibraryListAsync()
{
try
{
// If local.xml exists
if (File.Exists(Definitions.Global.Origin.ConfigFilePath))
{
var originConfigKeys = XDocument.Load(Definitions.Global.Origin.ConfigFilePath).Root?.Elements().ToDictionary(a => (string)a.Attribute("key"), a => (string)a.Attribute("value"));
if (originConfigKeys?.Count(x => x.Key == "DownloadInPlaceDir") == 0)
{
Logger.Log(NLog.LogLevel.Error, Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Origin_MissingKey)), new { OriginConfigFilePath = Definitions.Global.Origin.ConfigFilePath }));
}
else
{
if (Directory.Exists(originConfigKeys?["DownloadInPlaceDir"]))
{
AddNewLibraryAsync(originConfigKeys?["DownloadInPlaceDir"], true);
}
else
{
Logger.Info(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Origin_DirectoryNotExists)), new { NotFoundDirectoryFullPath = originConfigKeys["DownloadInPlaceDir"] }));
}
}
}
if (Directory.Exists(Definitions.Directories.Origin.LocalContentDirectory))
{
await Directory.EnumerateFiles(Definitions.Directories.Origin.LocalContentDirectory, "*.mfst", SearchOption.AllDirectories).ParallelForEachAsync(originApp =>
{
var appId = Path.GetFileNameWithoutExtension(originApp);
if (!appId.StartsWith("Origin"))
{
// Get game id by fixing file via adding : before integer part of the name
// for example OFB-EAST52017 converts to OFB-EAST:52017
var match = System.Text.RegularExpressions.Regex.Match(appId, @"^(.*?)(\d+)$");
if (!match.Success)
{
return(Task.CompletedTask);
}
appId = match.Groups[1].Value + ":" + match.Groups[2].Value;
}
Definitions.Global.Origin.AppIds.Add(new KeyValuePair <string, string>(new FileInfo(originApp).Directory.Name, appId));
return(Task.CompletedTask);
});
}
}
catch (Exception ex)
{
Logger.Fatal(ex);
}
}
public static void PopulateLibraryCMenuItems()
{
#region Library Context Menu Item Definitions
// Open library in explorer ({0})
var menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_Open)),
Action = "Disk",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FolderOpen, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Remove library & files
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_RemoveFromSteam)),
Action = "deleteLibrary",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.DeleteForever, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Delete games in library
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamLibrary_CMenu_DeleteGames)),
Action = "deleteLibrarySLM",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.DeleteSweep, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
ShowToNormal = false,
ShowToOffline = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
// Remove from SLM
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.RemoveFromSlm)),
Action = "RemoveFromList",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.PlaylistRemove, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.LibraryCMenuItems.Add(menuItem);
#endregion Library Context Menu Item Definitions
}
public static void PopulateAppCMenuItems()
{
#region App Context Menu Item Definitions
// Run
var menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Play)),
Action = "steam://run/{0}",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Play, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToSteamBackup = false,
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true,
ShowToSteamBackup = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compress
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Compress)),
Action = "Compress",
ShowToSteamBackup = false,
Icon = new PackIconOcticons()
{
Kind = PackIconOcticonsKind.FileZip, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Compact
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.Compact)),
Action = "compact",
ShowToCompressed = false,
ShowToSteamBackup = false,
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.ArrowCollapse, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
ShowToSteamBackup = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Show on disk
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DiskInfo)),
Action = "Disk",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FolderOpen, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// View ACF
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_ViewACF)),
Action = "acffile",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FileDocument, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
ShowToCompressed = false,
IsSeparator = true,
ShowToSteamBackup = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// View Store Page
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_ViewStore)),
Action = "steam://store/{0}",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Steam, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Verify files
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_VerifyFiles)),
Action = "verify",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.CheckAll, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
},
ShowToCompressed = false
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Google Search
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_GoogleSearch)),
Action = "google",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Google, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Youtube Search
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_YoutubeSearch)),
Action = "youtube",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Youtube, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Game hub
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_GameHub)),
Action = "steam://url/GameHub/{0}",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.BookOpenPageVariant, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Workshop
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_Workshop)),
Action = "steam://url/SteamWorkshopPage/{0}",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.FormatListCheckbox, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Subscribed Workshop Items
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_SubscribedWorkshopItems)),
Action = "https://steamcommunity.com/profiles/{1}/myworkshopfiles/?appid={0}&browsefilter=mysubscriptions&sortmethod=lastupdated",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.PlaylistCheck, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Separator
menuItem = new Definitions.ContextMenuItem
{
IsSeparator = true,
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using Task Manager)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DeleteFilesSLM)),
Action = "deleteappfiles",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.Delete, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
// Delete files (using Task Manager)
menuItem = new Definitions.ContextMenuItem
{
Header = SLM.Translate(nameof(Properties.Resources.SteamApp_CMenu_DeleteFilesTM)),
Action = "deleteappfilestm",
Icon = new PackIconMaterial()
{
Kind = PackIconMaterialKind.DeleteSweep, VerticalAlignment = VerticalAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, Foreground = new SolidColorBrush((Color)MahApps.Metro.ThemeManager.DetectAppStyle(Application.Current).Item2.Resources["AccentColor"])
}
};
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.Steam);
menuItem.AllowedLibraryTypes.Add(Definitions.Enums.LibraryType.SLM);
Definitions.List.AppCMenuItems.Add(menuItem);
#endregion App Context Menu Item Definitions
}
public static async Task CloseSteamAsync()
{
try
{
var ActiveSteamPath = GetActiveSteamProcessPath();
if (!string.IsNullOrEmpty(ActiveSteamPath))
{
if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosed)), SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosedMessage)), MessageDialogStyle.AffirmativeAndNegative).ConfigureAwait(true) == MessageDialogResult.Affirmative)
{
if (File.Exists(ActiveSteamPath))
{
Process.Start(ActiveSteamPath, "-shutdown");
}
else if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosed)), Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosedMessage2)), new { ActiveSteamPath }), MessageDialogStyle.AffirmativeAndNegative).ConfigureAwait(true) == MessageDialogResult.Affirmative)
{
foreach (var SteamProcess in Process.GetProcessesByName("Steam"))
{
SteamProcess.Kill();
}
}
else
{
throw new OperationCanceledException(SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosed_NotFoundAndUserCancelled)));
}
}
else
{
throw new OperationCanceledException(SLM.Translate(nameof(Properties.Resources.Steam_NeedsToBeClosed_UserCancelled)));
}
await Task.Delay(6000).ConfigureAwait(true);
}
}
catch (OperationCanceledException)
{ }
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public static void Start()
{
if (!Status && !Paused)
{
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_Active)), new { CurrentTime = DateTime.Now }));
CancellationToken = new CancellationTokenSource();
Status = true;
Task.Factory.StartNew(async() =>
{
try
{
while (!CancellationToken.IsCancellationRequested && Status)
{
if (TaskList.ToList().Any(x => !x.Completed))
{
await ProcessTaskAsync(TaskList.First(x => !x.Completed)).ConfigureAwait(false);
}
Thread.Sleep(100);
}
}
catch (OperationCanceledException)
{
Stop();
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_Stopped)), new { CurrentTime = DateTime.Now }));
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Logger.Fatal(ex);
}
});
}
else if (Paused)
{
Paused = false;
ActiveTask.mre.Set();
Main.FormAccessor.TaskManagerView.Button_StartTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_StartTaskManager.IsEnabled = false;
});
Main.FormAccessor.TaskManagerView.Button_PauseTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_PauseTaskManager.IsEnabled = true;
});
Main.FormAccessor.TaskManagerView.Button_StopTaskManager.Dispatcher.Invoke(delegate
{
Main.FormAccessor.TaskManagerView.Button_StopTaskManager.IsEnabled = true;
});
}
}
public static async void RestartSteamAsync()
{
try
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
if (await Main.FormAccessor.ShowMessageAsync(SLM.Translate(nameof(Properties.Resources.Steam_Start)), SLM.Translate(nameof(Properties.Resources.Steam_StartMessage)), MessageDialogStyle.AffirmativeAndNegative).ConfigureAwait(true) == MessageDialogResult.Affirmative)
{
await CloseSteamAsync().ConfigureAwait(true);
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steam.exe")))
{
Process.Start(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steam.exe"), "-silent");
}
}
else
{
throw new OperationCanceledException(SLM.Translate(nameof(Properties.Resources.Steam_Start_UserCancelled)));
}
}, System.Windows.Threading.DispatcherPriority.Normal).ConfigureAwait(true);
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
logger.Fatal(ex);
}
}
private static async Task ProcessTaskAsync(Definitions.List.TaskInfo CurrentTask)
{
try
{
TmInfoUpdate();
ActiveTask = CurrentTask;
CurrentTask.Active = true;
if (CurrentTask.SteamApp != null)
{
switch (CurrentTask.TaskType)
{
default:
await CurrentTask.SteamApp.CopyFilesAsync(CurrentTask, CancellationToken.Token).ConfigureAwait(false);
break;
case Definitions.Enums.TaskType.Delete:
await CurrentTask.SteamApp.DeleteFilesAsync(CurrentTask).ConfigureAwait(false);
CurrentTask.SteamApp.Library.Steam.Apps.Remove(CurrentTask.SteamApp);
break;
case Definitions.Enums.TaskType.Compact:
await CurrentTask.SteamApp.CompactTask(CurrentTask, CancellationToken.Token).ConfigureAwait(false);
break;
}
if (!CancellationToken.IsCancellationRequested && !CurrentTask.ErrorHappened)
{
if (CurrentTask.RemoveOldFiles && CurrentTask.TaskType != Definitions.Enums.TaskType.Delete)
{
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFiles)), new { CurrentTime = DateTime.Now, CurrentTask.SteamApp.AppName }));
await CurrentTask.SteamApp.DeleteFilesAsync(CurrentTask).ConfigureAwait(false);
CurrentTask.SteamApp.Library.Steam.Apps.Remove(CurrentTask.SteamApp);
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFilesCompleted)), new { CurrentTime = DateTime.Now, CurrentTask.SteamApp.AppName }));
}
if (CurrentTask.TargetLibrary?.Type == Definitions.Enums.LibraryType.Steam)
{
IsRestartRequired = true;
}
CurrentTask.TaskStatusInfo = SLM.Translate(nameof(Properties.Resources.TaskStatus_Completed));
CurrentTask.Active = false;
CurrentTask.Completed = true;
CurrentTask.TargetLibrary?.Steam.UpdateAppListAsync();
// Update library details
if (Definitions.SLM.CurrentSelectedLibrary == CurrentTask.SteamApp.Library)
{
App.UpdateAppPanel(CurrentTask.SteamApp.Library);
}
}
}
else if (CurrentTask.OriginApp != null)
{
switch (CurrentTask.TaskType)
{
default:
await CurrentTask.OriginApp.CopyFilesAsync(CurrentTask, CancellationToken.Token).ConfigureAwait(false);
break;
case Definitions.Enums.TaskType.Delete:
await CurrentTask.OriginApp.DeleteFilesAsync(CurrentTask);
CurrentTask.OriginApp.Library.Origin.Apps.Remove(CurrentTask.OriginApp);
break;
case Definitions.Enums.TaskType.Compact:
await CurrentTask.OriginApp.CompactTask(CurrentTask, CancellationToken.Token).ConfigureAwait(false);
break;
}
if (!CancellationToken.IsCancellationRequested && !CurrentTask.ErrorHappened)
{
if (CurrentTask.RemoveOldFiles && CurrentTask.TaskType != Definitions.Enums.TaskType.Delete)
{
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFiles)), new { CurrentTime = DateTime.Now, CurrentTask.OriginApp.AppName }));
await CurrentTask.OriginApp.DeleteFilesAsync(CurrentTask);
CurrentTask.OriginApp.Library.Origin.Apps.Remove(CurrentTask.OriginApp);
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFilesCompleted)), new { CurrentTime = DateTime.Now, CurrentTask.OriginApp.AppName }));
}
CurrentTask.TaskStatusInfo = SLM.Translate(nameof(Properties.Resources.TaskStatus_Completed));
CurrentTask.Active = false;
CurrentTask.Completed = true;
CurrentTask.TargetLibrary?.Origin.UpdateAppListAsync();
if (CurrentTask.Compress)
{
await CurrentTask.TargetLibrary?.Origin.Apps.FirstOrDefault(x => x.AppId == CurrentTask.OriginApp.AppId)?.InstallAsync();
}
// Update library details
if (Definitions.SLM.CurrentSelectedLibrary == CurrentTask.OriginApp.Library)
{
App.UpdateAppPanel(CurrentTask.OriginApp.Library);
}
}
}
if (TaskList.Count(x => !x.Completed) == 0)
{
if (Properties.Settings.Default.PlayASoundOnCompletion)
{
if (!string.IsNullOrEmpty(Properties.Settings.Default.CustomSoundFile) && File.Exists(Properties.Settings.Default.CustomSoundFile))
{
new System.Media.SoundPlayer(Properties.Settings.Default.CustomSoundFile).Play();
}
else
{
System.Media.SystemSounds.Exclamation.Play();
}
}
if (IsRestartRequired)
{
Steam.RestartSteamAsync();
IsRestartRequired = false;
}
}
if (Properties.Settings.Default.TaskManager_AutoClear && !CurrentTask.ErrorHappened)
{
RemoveTaskProgress.Report(CurrentTask);
}
SLM.Library.UpdateLibraryVisual();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Logger.Fatal(ex);
}
finally
{
TmInfoUpdate();
}
}
public static async void CheckForBackupUpdatesAsync()
{
try
{
if (Definitions.List.Libraries.Count(x => x.Type == Definitions.Enums.LibraryType.SLM && x.DirectoryInfo.Exists) == 0)
{
return;
}
var ProgressInformationMessage = await Main.FormAccessor.ShowProgressAsync(SLM.Translate(nameof(Properties.Resources.PleaseWait)), SLM.Translate(nameof(Properties.Resources.Steam_CheckForBackupUpdates))).ConfigureAwait(true);
ProgressInformationMessage.SetIndeterminate();
foreach (var CurrentLibrary in Definitions.List.Libraries.Where(x => x.Type == Definitions.Enums.LibraryType.SLM && x.DirectoryInfo.Exists).ToList())
{
if (CurrentLibrary.Apps.Count == 0)
{
continue;
}
foreach (var LibraryToCheck in Definitions.List.Libraries.Where(x => x.Type == Definitions.Enums.LibraryType.Steam))
{
foreach (var CurrentApp in CurrentLibrary.Apps.Where(x => !x.IsSteamBackup && !x.IsCompressed).ToList())
{
ProgressInformationMessage.SetMessage(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Steam_CheckForBackupUpdates_Progress)), new { CurrentAppName = CurrentApp.AppName }));
if (LibraryToCheck.Apps.Count(x => x.AppId == CurrentApp.AppId && x.LastUpdated > CurrentApp.LastUpdated && !x.IsSteamBackup) > 0)
{
var LatestApp = LibraryToCheck.Apps.First(x => x.AppId == CurrentApp.AppId && x.LastUpdated > CurrentApp.LastUpdated && !x.IsSteamBackup);
if (TaskManager.TaskList.Count(x => x.App.AppId == CurrentApp.AppId && !x.Completed && (x.TargetLibrary == LatestApp.Library || x.TargetLibrary == CurrentApp.Library)) == 0)
{
Definitions.List.TaskInfo newTask = new Definitions.List.TaskInfo
{
App = LatestApp,
TargetLibrary = CurrentApp.Library
};
TaskManager.AddTask(newTask);
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Steam_CheckForBackupUpdates_UpdateFound)), new { CurrentTime = DateTime.Now, CurrentAppName = CurrentApp.AppName, NewAppLastUpdatedOn = LatestApp.LastUpdated, CurrentAppLastUpdatedOn = CurrentApp.LastUpdated, CurrentAppSteamFullPath = CurrentApp.Library.Steam.FullPath, NewAppSteamFullPath = LatestApp.Library.Steam.FullPath }));
}
}
}
}
}
await ProgressInformationMessage.CloseAsync().ConfigureAwait(true);
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Steam_CheckForBackupUpdates_Completed)), new { CurrentTime = DateTime.Now }));
}
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public static void GenerateLibraryList()
{
try
{
// If local.xml exists
if (File.Exists(Definitions.Global.Origin.ConfigFilePath))
{
var OriginConfigKeys = XDocument.Load(Definitions.Global.Origin.ConfigFilePath).Root.Elements().ToDictionary(a => (string)a.Attribute("key"), a => (string)a.Attribute("value"));
if (OriginConfigKeys.Count(x => x.Key == "DownloadInPlaceDir") == 0)
{
logger.Log(NLog.LogLevel.Error, Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Origin_MissingKey)), new { OriginConfigFilePath = Definitions.Global.Origin.ConfigFilePath }));
}
else
{
if (Directory.Exists(OriginConfigKeys["DownloadInPlaceDir"]))
{
AddNewAsync(OriginConfigKeys["DownloadInPlaceDir"], true);
}
else
{
logger.Info(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.Origin_DirectoryNotExists)), new { NotFoundDirectoryFullPath = OriginConfigKeys["DownloadInPlaceDir"] }));
}
}
}
else /* Could not locate local.xml */ } {
}
public static void RemoveGivenFiles(List <string> FileList, List <string> DirectoryList = null, Definitions.List.TaskInfo CurrentTask = null)
{
try
{
Parallel.ForEach(FileList, currentFile =>
{
FileInfo File = new FileInfo(currentFile);
if (File.Exists)
{
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = Framework.StringFormat.Format(Functions.SLM.Translate(nameof(Properties.Resources.TaskStatus_DeletingFile)), new { FileName = File.Name, FormattedFileSize = FormatBytes(File.Length) });
}
System.IO.File.SetAttributes(File.FullName, FileAttributes.Normal);
File.Delete();
}
});
if (DirectoryList != null)
{
Parallel.ForEach(DirectoryList, currentDirectory =>
{
DirectoryInfo Directory = new DirectoryInfo(currentDirectory);
if (Directory.Exists)
{
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskStatus_DeletingDirectory)), new { DirectoryName = Directory.Name });
}
Directory.Delete();
}
});
}
if (CurrentTask != null)
{
CurrentTask.TaskStatusInfo = "";
}
}
catch (DirectoryNotFoundException ex)
{
logger.Error(ex);
}
catch (IOException ex)
{
logger.Error(ex);
}
catch (AggregateException ex)
{
logger.Error(ex);
}
catch (UnauthorizedAccessException ex)
{
logger.Error(ex);
}
catch (Exception ex)
{
logger.Fatal(ex);
Definitions.SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
}
}
private static async Task ProcessTaskAsync(Definitions.List.TaskInfo currentTask)
{
try
{
TmInfoUpdate();
ActiveTask = currentTask;
currentTask.Active = true;
switch (currentTask.TaskType)
{
default:
await currentTask.App.CopyFilesAsync(currentTask, CancellationToken.Token).ConfigureAwait(false);
break;
case TaskType.Delete:
await currentTask.App.DeleteFilesAsync(currentTask).ConfigureAwait(false);
currentTask.App.Library.Apps.Remove(currentTask.App);
break;
case TaskType.Compact:
await currentTask.App.CompactTask(currentTask, CancellationToken.Token).ConfigureAwait(false);
break;
}
if (!CancellationToken.IsCancellationRequested && !currentTask.ErrorHappened)
{
if (currentTask.RemoveOldFiles && currentTask.TaskType != TaskType.Delete && currentTask.TaskType != TaskType.Compact)
{
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFiles)), new { CurrentTime = DateTime.Now, currentTask.App.AppName }));
await currentTask.App.DeleteFilesAsync(currentTask).ConfigureAwait(false);
currentTask.App.Library.Apps.Remove(currentTask.App);
Main.FormAccessor.TmLogs.Report(Framework.StringFormat.Format(SLM.Translate(nameof(Properties.Resources.TaskManager_RemoveOldFilesCompleted)), new { CurrentTime = DateTime.Now, currentTask.App.AppName }));
}
if (currentTask.TargetLibrary?.Type == LibraryType.Steam)
{
_isRestartRequired = true;
}
currentTask.TaskStatusInfo = SLM.Translate(nameof(Properties.Resources.TaskStatus_Completed));
currentTask.Active = false;
currentTask.Completed = true;
currentTask.TargetLibrary?.UpdateAppList();
if (currentTask.AutoInstall && !currentTask.Compress)
{
while (currentTask.TargetLibrary.IsUpdatingAppList)
{
await Task.Delay(100);
}
switch (currentTask.TargetLibrary.Type)
{
case LibraryType.Steam:
case LibraryType.SLM:
// Not available
break;
case LibraryType.Origin:
case LibraryType.Uplay:
currentTask.TargetLibrary.Apps.First(x => x.AppId == currentTask.App.AppId && x.IsCompressed == currentTask.Compress)?.InstallAsync();
break;
}
}
// Update library details
if (Definitions.SLM.CurrentSelectedLibrary == currentTask.App.Library)
{
App.UpdateAppPanel(currentTask.App.Library);
}
}
if (TaskList.Count(x => !x.Completed) == 0)
{
if (Properties.Settings.Default.PlayASoundOnCompletion)
{
if (!string.IsNullOrEmpty(Properties.Settings.Default.CustomSoundFile) && File.Exists(Properties.Settings.Default.CustomSoundFile))
{
using (var soundPlayer = new System.Media.SoundPlayer(Properties.Settings.Default.CustomSoundFile))
{
soundPlayer.Play();
}
}
else
{
System.Media.SystemSounds.Exclamation.Play();
}
}
if (_isRestartRequired && !Properties.Settings.Default.TaskManager_SteamRestartSkip)
{
Steam.RestartSteamAsync();
_isRestartRequired = false;
}
}
if (Properties.Settings.Default.TaskManager_AutoClear && !currentTask.ErrorHappened)
{
RemoveTaskProgress.Report(currentTask);
}
SLM.Library.UpdateLibraryVisual();
}
catch (Exception ex)
{
Debug.WriteLine(ex);
Logger.Fatal(ex);
}
finally
{
TmInfoUpdate();
}
}
