public static void CreateNewLibrary(string newLibraryPath, bool Backup)
{
try
{
// If we are not creating a backup library
if (!Backup)
{
// Copy Steam.dll as steam needs it
File.Copy(Properties.Settings.Default.SteamInstallationPath + "Steam.dll", newLibraryPath + @"\Steam.dll", true);
// create SteamApps directory at requested directory
Directory.CreateDirectory(newLibraryPath + @"\SteamApps");
// If Steam.dll moved succesfully
if (File.Exists(newLibraryPath + @"\Steam.dll")) // in case of permissions denied
{
// Set libraryFolders.vdf path
string vdfPath = Properties.Settings.Default.SteamInstallationPath + @"SteamApps\libraryfolders.vdf";
// Call KeyValue in act
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file as text
Key.ReadFileAsText(vdfPath);
// Add our new library to vdf file so steam will know we have a new library
Key.Children.Add(new Framework.KeyValue((Key.Children.Count - 1).ToString(), newLibraryPath));
// Save vdf file
Key.SaveToFile(vdfPath, false);
// Show a messagebox to user about process
System.Windows.Forms.MessageBox.Show("New Steam Library added, Please Restart Steam to see it in work."); // to-do: edit text
// Update game libraries
UpdateLibraries();
}
else
// Show an error to user and cancel the process because we couldn't get Steam.dll in new library dir
System.Windows.Forms.MessageBox.Show("Failed to create new Steam Library, Try to run SLM as Administrator?");
}
else
{
// If backup directories in settings null
if (Properties.Settings.Default.BackupDirectories == null)
// make a new definition
Properties.Settings.Default.BackupDirectories = new System.Collections.Specialized.StringCollection();
// Add our newest backup library to settings
Properties.Settings.Default.BackupDirectories.Add(newLibraryPath + @"\");
// Update game libraries
UpdateLibraries();
// Save our settings
Functions.Settings.Save();
}
}
catch { }
}
public async void UpdateLibraryPathAsync(string NewLibraryPath)
{
try
{
await Functions.Steam.CloseSteamAsync();
// Make a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file
Key.ReadFileAsText(Global.Steam.vdfFilePath);
// Change old library path with new one
Key["Software"]["Valve"]["Steam"].Children.Find(key => key.Value.Contains(FullPath)).Value = NewLibraryPath;
// Update config.vdf file with changes
Key.SaveToFile(Global.Steam.vdfFilePath, false);
// 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 with some magic.
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf")))
{
File.Delete(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf"));
}
Functions.Steam.RestartSteamAsync();
}
catch (Exception ex)
{
logger.Fatal(ex);
SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
}
}
public static void GenerateLibraryList()
{
try
{
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.exe")))
{
AddNew(Properties.Settings.Default.steamInstallationPath, true);
}
// Make a KeyValue reader
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// If config.vdf exists
if (File.Exists(Definitions.Global.Steam.vdfFilePath))
{
// Read our vdf file as text
KeyValReader.ReadFileAsText(Definitions.Global.Steam.vdfFilePath);
KeyValReader = KeyValReader["Software"]["Valve"]["Steam"];
if (KeyValReader?.Children.Count > 0)
{
foreach (var key in KeyValReader.Children.Where(x => x.Name.StartsWith("BaseInstallFolder", StringComparison.OrdinalIgnoreCase)))
{
AddNew(key.Value);
}
Definitions.SLM.UserSteamID64 = (KeyValReader["Accounts"]?.Children.Count > 0) ? KeyValReader["Accounts"]?.Children.FirstOrDefault()?.Children.FirstOrDefault()?.Value : null;
}
}
else /* Could not locate LibraryFolders.vdf */ } {
}
public static void createNewLibrary(string newLibraryPath, bool Backup)
{
try
{
// If we are not creating a backup library
if (!Backup)
{
// Define steam dll paths for better looking
string currentSteamDLLPath = Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.dll");
string newSteamDLLPath = Path.Combine(newLibraryPath, "Steam.dll");
if (!File.Exists(newSteamDLLPath))
{
// Copy Steam.dll as steam needs it
File.Copy(currentSteamDLLPath, newSteamDLLPath, 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(newSteamDLLPath)) // in case of permissions denied
{
// Call KeyValue in act
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file as text
Key.ReadFileAsText(Definitions.Steam.vdfFilePath);
// Add our new library to vdf file so steam will know we have a new library
Key.Children[0].Children[0].Children[0].Children.Add(new Framework.KeyValue(string.Format("BaseInstallFolder_{0}", Definitions.List.Libraries.Select(x => !x.Backup).Count()), newLibraryPath));
// Save vdf file
Key.SaveToFile(Definitions.Steam.vdfFilePath, false);
// Show a messagebox to user about process
MessageBox.Show("new library created");
}
else
{
// Show an error to user and cancel the process because we couldn't get Steam.dll in new library dir
MessageBox.Show("failed to create new library");
}
}
// Add library to list
addNewLibrary(newLibraryPath, false, Backup);
// Save our settings
SLM.Settings.saveSettings();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public override async void RemoveLibraryAsync(bool withFiles)
{
try
{
if (withFiles)
{
DeleteFilesAsync();
}
List.Libraries.Remove(this);
if (Type != LibraryType.Steam)
{
return;
}
await Functions.Steam.CloseSteamAsync().ConfigureAwait(true);
// Make a KeyValue reader
var keyValReader = new Framework.KeyValue();
// Read vdf file
keyValReader.ReadFileAsText(Global.Steam.VdfFilePath);
// Remove old library
keyValReader["Software"]["Valve"]["Steam"].Children.RemoveAll(x => x.Value == FullPath);
var i = 1;
foreach (var key in keyValReader["Software"]["Valve"]["Steam"].Children.FindAll(x => x.Name.Contains("BaseInstallFolder")))
{
key.Name = $"BaseInstallFolder_{i}";
i++;
}
// Update libraryFolders.vdf file with changes
keyValReader.SaveToFile(Global.Steam.VdfFilePath, false);
// 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 with some magic.
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf")))
{
File.Delete(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf"));
}
Functions.Steam.RestartSteamAsync();
}
catch (Exception ex)
{
Logger.Fatal(ex);
}
}
public async void RemoveLibraryAsync(bool ShouldDeleteFiles)
{
try
{
if (ShouldDeleteFiles)
{
DeleteFilesAsync();
}
List.Libraries.Remove(List.Libraries.First(x => x == Library));
await Functions.Steam.CloseSteamAsync();
// Make a KeyValue reader
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// Read vdf file
KeyValReader.ReadFileAsText(Global.Steam.vdfFilePath);
// Remove old library
KeyValReader["Software"]["Valve"]["Steam"].Children.RemoveAll(x => x.Value == FullPath);
int i = 1;
foreach (Framework.KeyValue Key in KeyValReader["Software"]["Valve"]["Steam"].Children.FindAll(x => x.Name.Contains("BaseInstallFolder")))
{
Key.Name = $"BaseInstallFolder_{i}";
i++;
}
// Update libraryFolders.vdf file with changes
KeyValReader.SaveToFile(Global.Steam.vdfFilePath, false);
// 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 with some magic.
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf")))
{
File.Delete(Path.Combine(Properties.Settings.Default.steamInstallationPath, "steamapps", "libraryfolders.vdf"));
}
Functions.Steam.RestartSteamAsync();
}
catch (Exception ex)
{
logger.Fatal(ex);
SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
}
}
public static void GenerateLibraryList()
{
try
{
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.exe")))
{
AddNew(Properties.Settings.Default.steamInstallationPath, true);
}
// Make a KeyValue reader
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// If config.vdf exists
if (File.Exists(Definitions.Global.Steam.vdfFilePath))
{
// Read our vdf file as text
KeyValReader.ReadFileAsText(Definitions.Global.Steam.vdfFilePath);
KeyValReader = KeyValReader["Software"]["Valve"]["Steam"];
if (KeyValReader?.Children.Count > 0)
{
foreach (var key in KeyValReader.Children.Where(x => x.Name.StartsWith("BaseInstallFolder", StringComparison.OrdinalIgnoreCase)))
{
AddNew(key.Value);
}
if (KeyValReader["Accounts"]?.Children.Count > 0)
{
foreach (var account in KeyValReader["Accounts"].Children)
{
var steamID = account.Children.SingleOrDefault(x => x.Name == "SteamID");
if (steamID == null)
{
continue;
}
Definitions.List.SteamUserIDList.Add(new Tuple <string, string>(account.Name, steamID.Value));
}
Main.FormAccessor.SettingsView.SteamUserIDList.SelectedItem = Definitions.List.SteamUserIDList.Find(x => x.Item2 == Properties.Settings.Default.SteamID64);
}
}
}
else /* Could not locate LibraryFolders.vdf */ } {
}
public void updateLibraryPath(string newLibraryPath)
{
try
{
// Make a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file
Key.ReadFileAsText(Steam.vdfFilePath);
// Change old library path with new one
Key.Children[0].Children[0].Children[0].Children.Find(key => key.Value.Contains(fullPath)).Value = newLibraryPath;
// Update config.vdf file with changes
Key.SaveToFile(Steam.vdfFilePath, false);
}
catch { }
}
public void removeLibrary(bool deleteFiles)
{
try
{
if (deleteFiles)
{
Functions.fileSystem.deleteOldLibrary(this);
}
List.Libraries.Remove(this);
if (Backup)
{
Functions.SLM.Settings.updateBackupDirs();
Functions.SLM.Settings.saveSettings();
}
else
{
// Make a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// Read vdf file
Key.ReadFileAsText(Definitions.Steam.vdfFilePath);
// Remove old library
Key.Children[0].Children[0].Children[0].Children.RemoveAll(x => x.Value == fullPath);
int i = 1;
foreach (Framework.KeyValue key in Key.Children[0].Children[0].Children[0].Children.FindAll(x => x.Name.Contains("BaseInstallFolder")))
{
key.Name = string.Format("BaseInstallFolder_{0}", i);
i++;
}
// Update libraryFolders.vdf file with changes
Key.SaveToFile(Definitions.Steam.vdfFilePath, false);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public static void UpdateGamesList(Definitions.List.LibraryList Library)
{
try
{
// If our list is not empty
if (Definitions.List.Game.Count != 0)
// Clear the list
Definitions.List.Game.Clear();
// Foreach *.acf file found in library
foreach (Framework.FileData game in Framework.FastDirectoryEnumerator.EnumerateFiles(Library.Directory, "*.acf", SearchOption.TopDirectoryOnly))
{
// Define a new value and call KeyValue
Framework.KeyValue Key = new Framework.KeyValue();
// Read the *.acf file as text
Key.ReadFileAsText(game.Path);
// If key doesn't contains a child (value in acf file)
if (Key.Children.Count == 0)
// Skip this file (game)
continue;
// Make a new definition for game
Definitions.List.GamesList Game = new Definitions.List.GamesList();
// Set game appID
Game.appID = Convert.ToInt32(Key["appID"].Value);
// Set game name
Game.appName = Key["name"].Value;
// Set installation path
Game.installationPath = Key["installdir"].Value;
// Set game library
Game.Library = Library;
// If game has a folder in "common" dir, define it as exactInstallPath
if (Directory.Exists(Path.Combine(Library.Directory, "common", Game.installationPath)))
Game.exactInstallPath = Path.Combine(Library.Directory, "common", Game.installationPath);
// If game has a folder in "downloading" dir, define it as downloadPath
if (Directory.Exists(Path.Combine(Library.Directory, "downloading", Game.appID.ToString())))
Game.downloadPath = Path.Combine(Library.Directory, "downloading", Game.appID.ToString());
// If game has a folder in "workshop" dir, define it as workShopPath
if (Directory.Exists(Path.Combine(Library.Directory, "workshop", "content", Game.appID.ToString())))
Game.workShopPath = Path.Combine(Library.Directory, "workshop", "content", Game.appID.ToString());
// If game do not have a folder in "common" directory and "downloading" directory then skip this game
if (Game.exactInstallPath == null && Game.downloadPath == null)
continue; // Do not add pre-loads to list
// If SizeOnDisk value from .ACF file is not equals to 0
if (Key["SizeOnDisk"].Value != "0")
{
// If game has "common" folder
if (Game.exactInstallPath != null)
{
// If game size calculation method NOT set as "ACF"
if (Properties.Settings.Default.GameSizeCalculationMethod != "ACF")
// Calculate game size on disk
Game.sizeOnDisk += Functions.FileSystem.GetDirectorySize(Game.exactInstallPath, true);
else
// Else use the game size from .ACF file
Game.sizeOnDisk += Convert.ToInt64(Key["SizeOnDisk"].Value);
}
// If game has downloading files
if (Game.downloadPath != null)
{
// If game size calculation method NOT set as "ACF"
if (Properties.Settings.Default.GameSizeCalculationMethod != "ACF")
// Calculate "downloading" folder size
Game.sizeOnDisk += Functions.FileSystem.GetDirectorySize(Game.downloadPath, true);
}
// If game has "workshop" files
if (Game.workShopPath != null)
{
// If game size calculation method NOT set as "ACF"
if (Properties.Settings.Default.GameSizeCalculationMethod != "ACF")
// Calculate "workshop" files size
Game.sizeOnDisk += Functions.FileSystem.GetDirectorySize(Game.workShopPath, true);
}
}
else
// Else set game size to 0
Game.sizeOnDisk = 0;
// Add our game details to global list
Definitions.List.Game.Add(Game);
}
// If library is backup library
if (Library.Backup)
{
// Do a loop for each *.zip file in library
foreach (Framework.FileData gameArchive in Framework.FastDirectoryEnumerator.EnumerateFiles(Library.Directory, "*.zip", SearchOption.TopDirectoryOnly))
{
// Open archive for read
using (ZipArchive compressedArchive = ZipFile.OpenRead(gameArchive.Path))
{
// For each file in opened archive
foreach (ZipArchiveEntry file in compressedArchive.Entries)
{
// Check the file if it's name contains .ACF
if (file.Name.Contains(".acf"))
{
// If it contains
// Define a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// Open .acf file from archive as text
Key.ReadAsText(file.Open());
// If acf file has no children, skip this archive
if (Key.Children.Count == 0)
return;
// Define a new game
Definitions.List.GamesList Game = new Definitions.List.GamesList();
// Define our app ID
Game.appID = Convert.ToInt32(Key["appID"].Value);
// Define our app name
Game.appName = Key["name"].Value;
// Define it is an archive
Game.Compressed = true;
// Define installation path for game
Game.installationPath = Key["installdir"].Value;
// Define our library
Game.Library = Library;
// If user want us to get archive size from real uncompressed size
if (Properties.Settings.Default.ArchiveSizeCalculationMethod.StartsWith("Uncompressed"))
{
// Open archive to read
using (ZipArchive zip = ZipFile.OpenRead(Path.Combine(Game.Library.Directory, Game.appID + ".zip")))
{
// For each file in archive
foreach (ZipArchiveEntry entry in zip.Entries)
{
// Add file size to sizeOnDisk
Game.sizeOnDisk += entry.Length;
}
}
}
// Else
else
{
// Use FileInfo to get our archive details
FileInfo zip = new FileInfo(Path.Combine(Game.Library.Directory, Game.appID + ".zip"));
// And set archive size as game size
Game.sizeOnDisk = zip.Length;
}
// Add our new game to global definiton
Definitions.List.Game.Add(Game);
// Update main form as visual
Functions.Games.UpdateMainForm();
// we found what we are looking for, return
return;
}
}
}
}
}
// Focus to game list panel
Definitions.Accessors.MainForm.panel_GameList.Focus();
// Update main form as visual
Functions.Games.UpdateMainForm();
}
catch (Exception ex)
{
// If user want us to log errors to file
if (Properties.Settings.Default.LogErrorsToFile)
// Log
Functions.Log.ErrorsToFile("UpdateGameList", ex.ToString());
// Show a messagebox to user
MessageBox.Show("An error happened while updating game list!\n" + ex.ToString());
}
}
public static void GenerateLibraryList()
{
try
{
if (!string.IsNullOrEmpty(Properties.Settings.Default.SteamID64))
{
var localConfigFilePath = Path.Combine(Properties.Settings.Default.steamInstallationPath, "userdata", Framework.SteamIDConvert.Steam64ToSteam32(Convert.ToInt64(Properties.Settings.Default.SteamID64)).Split(':').Last(), "config", "localconfig.vdf");
if (File.Exists(localConfigFilePath))
{
Framework.KeyValue configFile = new Framework.KeyValue();
configFile.ReadFileAsText(localConfigFilePath);
var appsPath = configFile["Software"]["Valve"]["Steam"]["apps"];
if (appsPath?.Children.Count > 0)
{
foreach (var app in appsPath.Children)
{
var lastPlayed = app["LastPlayed"].Value;
if (lastPlayed != null && !Definitions.List.SteamApps_LastPlayedDic.ContainsKey(Convert.ToInt32(app.Name)))
{
Definitions.List.SteamApps_LastPlayedDic.Add(Convert.ToInt32(app.Name), new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(Convert.ToInt64(lastPlayed)));
}
}
}
}
}
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.exe")))
{
AddNew(Properties.Settings.Default.steamInstallationPath, true);
}
// If config.vdf exists
if (File.Exists(Definitions.Global.Steam.vdfFilePath))
{
// Make a KeyValue reader
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// Read our vdf file as text
KeyValReader.ReadFileAsText(Definitions.Global.Steam.vdfFilePath);
KeyValReader = KeyValReader["Software"]["Valve"]["Steam"];
if (KeyValReader?.Children.Count > 0)
{
foreach (var key in KeyValReader.Children.Where(x => x.Name.StartsWith("BaseInstallFolder", StringComparison.OrdinalIgnoreCase)))
{
AddNew(key.Value);
}
if (KeyValReader["Accounts"]?.Children.Count > 0)
{
foreach (var account in KeyValReader["Accounts"].Children)
{
var steamID = account.Children.SingleOrDefault(x => x.Name == "SteamID");
if (steamID == null)
{
continue;
}
Definitions.List.SteamUserIDList.Add(new Tuple <string, string>(account.Name, steamID.Value));
}
Main.FormAccessor.SettingsView.SteamUserIDList.SelectedItem = Definitions.List.SteamUserIDList.Find(x => x.Item2 == Properties.Settings.Default.SteamID64);
}
}
}
else /* Could not locate LibraryFolders.vdf */ } {
}
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();
// 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);
}, System.Windows.Threading.DispatcherPriority.Normal);
logger.Fatal(ex);
}
catch (Exception ex)
{
logger.Fatal(ex);
}
}
public void UpdateAppList()
{
try
{
SteamAppsFolder.Refresh();
if (!SteamAppsFolder.Exists)
{
SteamAppsFolder.Create();
SteamAppsFolder.Refresh();
if (!SteamAppsFolder.Exists)
{
MessageBox.Show("Can not create steam apps folder at: " + SteamAppsFolder.FullName + "\n\nIf you believe this path exists and SLM can't do it's job, please contact with me.");
return;
}
}
if (Apps.Count > 0)
{
Apps.Clear();
}
// Foreach *.acf file found in library
Parallel.ForEach(SteamAppsFolder.EnumerateFiles("appmanifest_*.acf", SearchOption.TopDirectoryOnly).ToList(), AcfFile =>
{
// Define a new value and call KeyValue
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// Read the *.acf file as text
KeyValReader.ReadFileAsText(AcfFile.FullName);
// If key doesn't contains a child (value in acf file)
if (KeyValReader.Children.Count == 0)
{
List.LCItems.Add(new List.JunkInfo
{
FSInfo = new FileInfo(AcfFile.FullName),
Size = AcfFile.Length,
Library = Library
});
return;
}
Functions.App.AddSteamApp(Convert.ToInt32(KeyValReader["appID"].Value), KeyValReader["name"].Value ?? KeyValReader["UserConfig"]["name"].Value, KeyValReader["installdir"].Value, Library, Convert.ToInt64(KeyValReader["SizeOnDisk"].Value), Convert.ToInt64(KeyValReader["LastUpdated"].Value), false);
});
// Do a loop for each *.zip file in library
Parallel.ForEach(Directory.EnumerateFiles(SteamAppsFolder.FullName, "*.zip", SearchOption.TopDirectoryOnly).ToList(), ArchiveFile => Functions.App.ReadDetailsFromZip(ArchiveFile, Library));
SteamBackupsFolder.Refresh();
if (Library.Type == Enums.LibraryType.SLM && SteamBackupsFolder.Exists)
{
foreach (FileInfo SkuFile in SteamBackupsFolder.EnumerateFiles("*.sis", SearchOption.AllDirectories).ToList())
{
Framework.KeyValue KeyValReader = new Framework.KeyValue();
KeyValReader.ReadFileAsText(SkuFile.FullName);
string[] AppNames = System.Text.RegularExpressions.Regex.Split(KeyValReader["name"].Value, " and ");
int i = 0;
long AppSize = Functions.FileSystem.GetDirectorySize(SkuFile.Directory, true);
foreach (Framework.KeyValue App in KeyValReader["apps"].Children)
{
if (Apps.Count(x => x.AppID == Convert.ToInt32(App.Value) && x.IsSteamBackup) > 0)
{
continue;
}
Functions.App.AddSteamApp(Convert.ToInt32(App.Value), AppNames[i], SkuFile.DirectoryName, Library, AppSize, SkuFile.LastWriteTimeUtc.ToUnixTimestamp(), false, true);
if (AppNames.Length > 1)
{
i++;
}
}
}
}
if (SLM.CurrentSelectedLibrary != null)
{
if (SLM.CurrentSelectedLibrary == Library)
{
Functions.App.UpdateAppPanel(Library);
}
}
}
catch (UnauthorizedAccessException uaex)
{
Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
await Main.FormAccessor.ShowMessageAsync("UnauthorizedAccessException!", $"[{FullPath}] An error releated to folder permissions happened during generating library content. Running SLM as Administrator might help.\n\nError: {uaex.Message}");
}, System.Windows.Threading.DispatcherPriority.Normal);
}
catch (DirectoryNotFoundException dnfex)
{
Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
await Main.FormAccessor.ShowMessageAsync("UnauthorizedAccessException!", $"[{FullPath}] Folder couldn't be created/not found. Running SLM as Administrator might help.\n\nIf you believe this path exists and SLM can't do it's job, please contact with me.\n\nError: {dnfex.Message}");
}, System.Windows.Threading.DispatcherPriority.Normal);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
logger.Fatal(ex);
SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
}
}
public void UpdateGameList()
{
try
{
if (!steamAppsPath.Exists)
{
steamAppsPath.Create();
}
else if (Games.Count > 0)
{
Games.Clear();
}
// Foreach *.acf file found in library
//foreach (string game in Directory.EnumerateFiles(steamAppsPath.FullName, "*.acf", SearchOption.TopDirectoryOnly))
Parallel.ForEach(steamAppsPath.EnumerateFiles("*.acf", SearchOption.TopDirectoryOnly), acfFilePath =>
{
// Define a new value and call KeyValue
Framework.KeyValue Key = new Framework.KeyValue();
// Read the *.acf file as text
Key.ReadFileAsText(acfFilePath.FullName);
// If key doesn't contains a child (value in acf file)
if (Key.Children.Count == 0)
{
return;
}
Functions.Games.AddNewGame(acfFilePath.FullName, Convert.ToInt32(Key["appID"].Value), !string.IsNullOrEmpty(Key["name"].Value) ? Key["name"].Value : Key["UserConfig"]["name"].Value, Key["installdir"].Value, this, Convert.ToInt64(Key["SizeOnDisk"].Value), false);
});
// Do a loop for each *.zip file in library
Parallel.ForEach(Directory.EnumerateFiles(steamAppsPath.FullName, "*.zip", SearchOption.TopDirectoryOnly), gameArchive =>
{
Functions.Games.readGameDetailsFromZip(gameArchive, this);
});
// If library is backup library
if (Backup)
{
foreach (string skuFile in Directory.EnumerateFiles(fullPath, "*.sis", SearchOption.AllDirectories))
{
Framework.KeyValue Key = new Framework.KeyValue();
Key.ReadFileAsText(skuFile);
string[] name = System.Text.RegularExpressions.Regex.Split(Key["name"].Value, " and ");
int i = 0;
long gameSize = Functions.fileSystem.GetDirectorySize(new DirectoryInfo(skuFile).Parent.FullName, true);
foreach (Framework.KeyValue app in Key["apps"].Children)
{
if (Games.Count(x => x.appID == Convert.ToInt32(app.Value)) > 0)
{
continue;
}
Functions.Games.AddNewGame(skuFile, Convert.ToInt32(app.Value), name[i], Path.GetDirectoryName(skuFile), this, gameSize, false, true);
if (name.Count() > 1)
{
i++;
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public static void generateLibraryList()
{
try
{
// If we already have definitions in our list
if (Definitions.List.Libraries.Count != 0)
{
// Clear them so they don't conflict
Definitions.List.Libraries.Clear();
}
if (File.Exists(Path.Combine(Properties.Settings.Default.steamInstallationPath, "Steam.exe")))
{
addNewLibrary(Properties.Settings.Default.steamInstallationPath, true, false);
}
// Make a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// If config.vdf exists
if (File.Exists(Definitions.Steam.vdfFilePath))
{
// Read our vdf file as text
Key.ReadFileAsText(Definitions.Steam.vdfFilePath);
// Set user id from config file
Definitions.SLM.userSteamID64 = Key.Children[0].Children[0].Children[0].Children.Find(x => x.Name == "Accounts").Children[0].Children[0].Value;
foreach (Framework.KeyValue key in Key.Children[0].Children[0].Children[0].Children.FindAll(x => x.Name.Contains("BaseInstallFolder")))
{
addNewLibrary(key.Value, false, false);
}
}
else /* Could not locate LibraryFolders.vdf */ } {
// If we have a backup library(s)
if (Properties.Settings.Default.backupDirectories != null)
{
// for each backup library we have do a loop
foreach (string backupDirectory in Properties.Settings.Default.backupDirectories)
{
// If directory not exists
if (!Directory.Exists(backupDirectory))
{
// Make a new dialog and ask user to update library path
MessageBoxResult askUserToUpdatePath = MessageBox.Show("Backup library couldn't be found, would you like to select a new path?", $"Backup library ({backupDirectory}) couldn't be found!", MessageBoxButton.YesNo, MessageBoxImage.Question);
// If user wants to update
if (askUserToUpdatePath == MessageBoxResult.Yes)
{
// Show another dialog to select new path
System.Windows.Forms.FolderBrowserDialog newBackupDirectoryPath = new System.Windows.Forms.FolderBrowserDialog();
// If new path selected from dialog
if (newBackupDirectoryPath.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
// define selected path to variable
string newLibraryPath = newBackupDirectoryPath.SelectedPath;
// Check if the selected path is exists
if (!libraryExists(newLibraryPath))
{
// If not exists then get directory root of selected path and see if it is equals with our selected path
if (Directory.GetDirectoryRoot(newLibraryPath) != newLibraryPath)
{
addNewLibrary(newLibraryPath, false, true);
}
else
{
// Else show an error message to user
MessageBox.Show("Libraries can not be created at root");
}
}
else
{
MessageBox.Show("Library exists");
}
}
}
}
else
{
addNewLibrary(backupDirectory, false, true);
}
}
}
}
public static void UpdateLibraries()
{
try
{
// If we already have definitions in our list
if (Definitions.List.Library.Count != 0)
// Clear them so they don't conflict
Definitions.List.Library.Clear();
// If Steam.exe not exists in the path we set then return
if (!File.Exists(Properties.Settings.Default.SteamInstallationPath + "Steam.exe")) return;
// Our main library doesn't included in LibraryFolders.vdf so we have to include it manually
Definitions.List.LibraryList Library = new Definitions.List.LibraryList();
// Tell it is our main game library which can be handy in future
Library.Main = true;
// Define our library path to SteamApps
Library.Directory = Properties.Settings.Default.SteamInstallationPath + @"SteamApps\";
// Count how many games we have installed in our library
Library.GameCount = Games.GetGamesCountFromLibrary(Library);
// And add collected informations to our global list
Definitions.List.Library.Add(Library);
// Make a KeyValue reader
Framework.KeyValue Key = new Framework.KeyValue();
// Define our LibraryFolders.VDF path for easier use
string vdfFilePath = Properties.Settings.Default.SteamInstallationPath + @"SteamApps\libraryfolders.vdf";
// If LibraryFolders.vdf exists
if (System.IO.File.Exists(vdfFilePath))
{
// Read our vdf file as text
Key.ReadFileAsText(vdfFilePath);
// Until someone gives a better idea, try to look for 255 Keys but break at first null key
for (int i = 1; i < Definitions.Steam.maxLibraryCount; i++)
{
// break if key is not exists
if (Key[i.ToString()].Value == null)
break;
// Define a new library
Library = new Definitions.List.LibraryList();
// Define library path
Library.Directory = Key[i.ToString()].Value + @"\SteamApps\";
// Define game count in library
Library.GameCount = Games.GetGamesCountFromLibrary(Library);
// Add our new library to list
Definitions.List.Library.Add(Library);
}
}
else { /* Could not locate LibraryFolders.vdf */ }
// If we have a backup library(s)
if (Properties.Settings.Default.BackupDirectories != null)
{
// for each backup library we have do a loop
foreach (object backupDirectory in Properties.Settings.Default.BackupDirectories)
{
// Define a new library
Library = new Definitions.List.LibraryList();
// Define it is a backup library
Library.Backup = true;
// Define library path
Library.Directory = backupDirectory.ToString();
// Define game count in library
Library.GameCount = Functions.Games.GetGamesCountFromLibrary(Library);
// Add our new library to list
Definitions.List.Library.Add(Library);
}
}
// Update Libraries List visually
UpdateMainForm();
}
catch { }
}
public override async void UpdateAppList()
{
try
{
if (IsUpdatingAppList)
{
return;
}
IsUpdatingAppList = true;
DirectoryList["SteamApps"].Refresh();
if (!DirectoryList["SteamApps"].Exists)
{
DirectoryList["SteamApps"].Create();
DirectoryList["SteamApps"].Refresh();
if (!DirectoryList["SteamApps"].Exists)
{
MessageBox.Show(Framework.StringFormat.Format(
Functions.SLM.Translate(nameof(Properties.Resources.SteamAppsFolderNotExists)),
new { SteamAppsFolderFullPath = DirectoryList["SteamApps"].FullName }));
return;
}
}
if (Apps.Count > 0)
{
Apps.Clear();
}
// Foreach *.acf file found in library
await DirectoryList["SteamApps"].EnumerateFiles("appmanifest_*.acf", SearchOption.TopDirectoryOnly)
.ParallelForEachAsync(
async acfFile =>
{
// Define a new value and call KeyValue
var keyValReader = new Framework.KeyValue();
// Read the *.acf file as text
keyValReader.ReadFileAsText(acfFile.FullName);
// If key doesn't contains a child (value in acf file)
if (keyValReader.Children.Count == 0)
{
if (List.IgnoredJunkItems.Contains(acfFile.FullName))
{
return;
}
List.LcProgress.Report(new List.JunkInfo
{
FSInfo = new FileInfo(acfFile.FullName),
Size = Functions.FileSystem.FormatBytes(acfFile.Length),
Library = this,
Tag = JunkType.CorruptedDataFile
});
return;
}
await Functions.App.AddSteamAppAsync(Convert.ToInt32(keyValReader["appid"].Value),
keyValReader["name"].Value ?? keyValReader["UserConfig"]["name"].Value,
keyValReader["installdir"].Value, Convert.ToInt32(keyValReader["StateFlags"].Value),
this, Convert.ToInt64(keyValReader["SizeOnDisk"].Value),
Convert.ToInt64(keyValReader["LastUpdated"].Value), false).ConfigureAwait(false);
}).ConfigureAwait(false);
// Do a loop for each *.zip file in library
await Directory.EnumerateFiles(DirectoryList["SteamApps"].FullName, "*.zip", SearchOption.TopDirectoryOnly)
.ParallelForEachAsync(async archive => { await Task.Run(() => Functions.App.ReadDetailsFromZip(archive, this)).ConfigureAwait(false); }).ConfigureAwait(false);
DirectoryList["SteamBackups"].Refresh();
if (Type == LibraryType.SLM && DirectoryList["SteamBackups"].Exists)
{
await DirectoryList["SteamBackups"].EnumerateFiles("*.sis", SearchOption.AllDirectories).ParallelForEachAsync(
async skuFile =>
{
var keyValReader = new Framework.KeyValue();
keyValReader.ReadFileAsText(skuFile.FullName);
var appNames = System.Text.RegularExpressions.Regex.Split(keyValReader["name"].Value, " and ");
var i = 0;
var appSize = Functions.FileSystem.GetDirectorySize(skuFile.Directory, true);
foreach (var app in keyValReader["apps"].Children)
{
if (Apps.Count(x => x.AppId == Convert.ToInt32(app.Value) && x.IsSteamBackup) > 0)
{
continue;
}
await Functions.App.AddSteamAppAsync(Convert.ToInt32(app.Value), appNames[i],
skuFile.DirectoryName, 4, this, appSize, skuFile.LastWriteTimeUtc.ToUnixTimestamp(),
false, true).ConfigureAwait(false);
if (appNames.Length > 1)
{
i++;
}
}
}).ConfigureAwait(false);
}
if (SLM.CurrentSelectedLibrary != null && SLM.CurrentSelectedLibrary == this)
{
Functions.App.UpdateAppPanel(this);
}
IsUpdatingAppList = false;
}
catch (UnauthorizedAccessException ex)
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(
async delegate
{
await Main.FormAccessor.ShowMessageAsync(
Functions.SLM.Translate(nameof(Properties.Resources.UnauthorizedAccessException)),
Framework.StringFormat.Format(
Functions.SLM.Translate(nameof(Properties.Resources.UnauthorizedAccessExceptionMessage)),
new { FullPath, ExceptionMessage = ex.Message })).ConfigureAwait(true);
}, System.Windows.Threading.DispatcherPriority.Normal).ConfigureAwait(true);
IsUpdatingAppList = false;
}
catch (DirectoryNotFoundException ex)
{
await Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(
async delegate
{
await Main.FormAccessor.ShowMessageAsync(
Functions.SLM.Translate(nameof(Properties.Resources.DirectoryNotFoundException)),
Framework.StringFormat.Format(
Functions.SLM.Translate(nameof(Properties.Resources.DirectoryNotFoundExceptionMessage)),
new { FolderfullPath = FullPath, ExceptionMessage = ex.Message }))
.ConfigureAwait(true);
}, System.Windows.Threading.DispatcherPriority.Normal).ConfigureAwait(true);
IsUpdatingAppList = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
Logger.Fatal(ex);
IsUpdatingAppList = false;
}
}
public void UpdateAppList()
{
try
{
SteamAppsFolder.Refresh();
if (!SteamAppsFolder.Exists)
{
SteamAppsFolder.Create();
SteamAppsFolder.Refresh();
if (!SteamAppsFolder.Exists)
{
MessageBox.Show(Framework.StringFormat.Format(Functions.SLM.Translate(nameof(Properties.Resources.SteamLibrary_CantCreate)), new { SteamAppsFolderFullPath = SteamAppsFolder.FullName }));
return;
}
}
if (Apps.Count > 0)
{
Apps.Clear();
}
// Foreach *.acf file found in library
foreach (FileInfo AcfFile in SteamAppsFolder.EnumerateFiles("appmanifest_*.acf", SearchOption.TopDirectoryOnly).ToList())
{
// Define a new value and call KeyValue
Framework.KeyValue KeyValReader = new Framework.KeyValue();
// Read the *.acf file as text
KeyValReader.ReadFileAsText(AcfFile.FullName);
// If key doesn't contains a child (value in acf file)
if (KeyValReader.Children.Count == 0)
{
List.LCProgress.Report(new List.JunkInfo
{
FSInfo = new FileInfo(AcfFile.FullName),
Size = AcfFile.Length,
Library = Library
});
continue;
}
Functions.App.AddSteamApp(Convert.ToInt32(KeyValReader["appID"].Value), KeyValReader["name"].Value ?? KeyValReader["UserConfig"]["name"].Value, KeyValReader["installdir"].Value, Library, Convert.ToInt64(KeyValReader["SizeOnDisk"].Value), Convert.ToInt64(KeyValReader["LastUpdated"].Value), false);
}
// Do a loop for each *.zip file in library
Parallel.ForEach(Directory.EnumerateFiles(SteamAppsFolder.FullName, "*.zip", SearchOption.TopDirectoryOnly).ToList(), ArchiveFile => Functions.App.ReadDetailsFromZip(ArchiveFile, Library));
SteamBackupsFolder.Refresh();
if (Library.Type == Enums.LibraryType.SLM && SteamBackupsFolder.Exists)
{
foreach (FileInfo SkuFile in SteamBackupsFolder.EnumerateFiles("*.sis", SearchOption.AllDirectories).ToList())
{
Framework.KeyValue KeyValReader = new Framework.KeyValue();
KeyValReader.ReadFileAsText(SkuFile.FullName);
string[] AppNames = System.Text.RegularExpressions.Regex.Split(KeyValReader["name"].Value, " and ");
int i = 0;
long AppSize = Functions.FileSystem.GetDirectorySize(SkuFile.Directory, true);
foreach (Framework.KeyValue App in KeyValReader["apps"].Children)
{
if (Apps.Count(x => x.AppID == Convert.ToInt32(App.Value) && x.IsSteamBackup) > 0)
{
continue;
}
Functions.App.AddSteamApp(Convert.ToInt32(App.Value), AppNames[i], SkuFile.DirectoryName, Library, AppSize, SkuFile.LastWriteTimeUtc.ToUnixTimestamp(), false, true);
if (AppNames.Length > 1)
{
i++;
}
}
}
}
if (SLM.CurrentSelectedLibrary != null && SLM.CurrentSelectedLibrary == Library)
{
Functions.App.UpdateAppPanel(Library);
}
}
catch (UnauthorizedAccessException uaex)
{
Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
await Main.FormAccessor.ShowMessageAsync(Functions.SLM.Translate(nameof(Properties.Resources.UnauthorizedAccessException)), Framework.StringFormat.Format(Functions.SLM.Translate(nameof(Properties.Resources.UnauthorizedAccessExceptionMessage)), new { FullPath, ExceptionMessage = uaex.Message }));
}, System.Windows.Threading.DispatcherPriority.Normal);
}
catch (DirectoryNotFoundException dnfex)
{
Main.FormAccessor.AppView.AppPanel.Dispatcher.Invoke(async delegate
{
await Main.FormAccessor.ShowMessageAsync(Functions.SLM.Translate(nameof(Properties.Resources.DirectoryNotFoundException)), Framework.StringFormat.Format(Functions.SLM.Translate(nameof(Properties.Resources.DirectoryNotFoundExceptionMessage)), new { FolderfullPath = FullPath, ExceptionMessage = dnfex.Message }));
}, System.Windows.Threading.DispatcherPriority.Normal);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
logger.Fatal(ex);
}
}
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();
// 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("New Steam library 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("Failed to copy Steam.dll into new library directory. Permission error, maybe?");
}
}
// Add library to list
AddNew(NewLibraryPath);
// Save our settings
SLM.Settings.SaveSettings();
}
catch (Exception ex)
{
logger.Fatal(ex);
Definitions.SLM.RavenClient.Capture(new SharpRaven.Data.SentryEvent(ex));
}
}