TreeNode AddNodeToNode(string Name, VDFData parentVDFDataStructure, TreeNodeVDFTag treeNodeTag, TreeNode nodeSelected)
{
TreeNode newTreeNode;
if (treeNodeTag.TagType == TreeNodeVDFTag.Type.Node) //If we have the node itself selected on our Treeview, we just need to call the AddNodeToNode method directly.
{
newTreeNode = AddNodeToNode(Name, nodeSelected, parentVDFDataStructure, treeNodeTag.Token as VDFNode);
}
else
{
//We will need to retrieve the parent of this key for this one if the key is the one that is selected.
if (nodeSelected.Parent == null) //Make sure that the parent of the TreeNode is set to another TreeNode
{
throw new NullReferenceException("TreeNode " + nodeSelected.Text + " parent property is not set!");
}
VDFKey selectedKey = treeNodeTag.Token as VDFKey; //Cast our token to key first.
if (selectedKey.Parent == null)
{
throw new NullReferenceException("Parent property of key " + selectedKey.Name + " is not set!");
}
VDFNode parentNode = selectedKey.Parent;
newTreeNode = AddNodeToNode(Name, nodeSelected.Parent, vdfData, parentNode);
}
return(newTreeNode);
}
/// <summary>
/// Retrieves all the Steam Apps under the specified Library Folder.
/// </summary>
/// <param name="LibPath">The Library Directory to search on.</param>
/// <returns></returns>
public static List <SteamApp> RetrieveAppsUnderLibraryFolder(string LibPath)
{
List <SteamApp> steamapps = new List <SteamApp>();
string steamAppsFolderPath = LibPath + "\\" + SteamAppsManager.STEAM_APPS_DIRNAME; //This is the folder that contains the application manifests.
if (!Directory.Exists(steamAppsFolderPath))
{
return(steamapps);
}
string[] manifests = Directory.GetFiles(steamAppsFolderPath, APPMANIFEST_SEARCH_STRING); //Search for the application manifests under the SteamApps Folder of the library.
if (manifests.Length == 0)
{
return(steamapps);
}
foreach (string manifest in manifests) //Parse all our manifest file in to a SteamApp instance.
{
VDFData parsedData;
bool parseResult = VDFData.TryParseFile(manifest, out parsedData); //Added this lines of code as there might be App manifests that are corrupted or empty.
if (parseResult && parsedData.Nodes != null && parsedData.Nodes.Count != 0)
{
steamapps.Add(new SteamApp(parsedData, LibPath));
}
}
return(steamapps);
}
const string APPMANIFEST_SEARCH_STRING = "appmanifest_*.acf"; //The search pattern to be used for searching steam apps manifest.
/// <summary>
/// Lists all the library folders of the steam installation.
/// </summary>
/// <param name="MainSteamInstallPath">The main directory of steam. (The installation folder.)</param>
/// <returns></returns>
public static List <string> RetrieveLibraryFolders(string MainSteamInstallPath)
{
List <string> libraryFolders = new List <string>(1); //Initialize our list of library folders with a count of 1 as we know that the InstallDir is a library folder.
libraryFolders.Add(MainSteamInstallPath);
//Let us now locate the file that contains the list of all the steam library folders in the machine.
string LibFileFullPath = MainSteamInstallPath + "\\" + SteamAppsManager.STEAM_APPS_DIRNAME + "\\" + LIBRARY_FOLDERS_NAME; //The full path of the library folders file.
if (!File.Exists(LibFileFullPath))
{
return(libraryFolders);
}
VDFData vdfReader = new VDFData(LibFileFullPath);
VDFNode vNode = vdfReader.Nodes.FindNode(LIBFILE_NODE_NAME); //Find the node that contains the list of steam libraries.
if (vNode == null || vNode.Keys == null || vNode.Keys.Count == 0) //If it isn't found or the Nodes key is null or empty, there's nothing else to be done. Return the list of libraryfolders that we already have. (which is just MainSteamInstallPath)
{
return(libraryFolders);
}
foreach (VDFKey vKey in vNode.Keys) //List all the keys inside the vNode node.
{
if (vKey.Name.IsInteger()) //As per what I've seen from the Library Folders file, it seems that the key name for the location of the folders itself is a number so check if the key name is a number.
{
libraryFolders.Add(vKey.Value);
}
}
return(libraryFolders);
}
public void UpdateAppsFromSharedConfig()
{
_sharedConfig = new VDFData(File.ReadAllText(_sharedConfigPath), false);
var apps = _sharedConfig.Nodes[0].Node("Software").Node("Valve").Node("Steam").Node("apps").Nodes;
foreach (var app in apps)
{
var appId = app.Name;
var steamApp = Apps.FirstOrDefault(a => a.Id.ToString() == appId);
if (steamApp == null)
{
int id;
if (int.TryParse(app.Name, out id))
{
steamApp = new AppInfo(id);
Apps.Add(steamApp);
}
}
if (steamApp != null)
{
if (app.ContainsNode("tags"))
{
foreach (var tag in app.Node("tags").Keys.Select(k => k.Value))
{
steamApp.SetTag(tag, true);
}
}
}
}
UpdateTags();
}
TreeNode CreateNewNode(string Name, VDFData parentVDFStructure, VDFNode parentNode, out VDFNode newNode)
{
newNode = new VDFNode(Name, parentVDFStructure, parentNode); //Create our new VDFNode first which will be referenced by our newNode argument (which will be passed back to the calling method.)
TreeNode newTreeNode = new TreeNode(Name);
newTreeNode.Tag = new TreeNodeVDFTag(TreeNodeVDFTag.Type.Node, newNode); //Set the tag to our newNode. Make sure to use VDFTag.
return(newTreeNode);
}
TreeNode AddRootNode(string Name, VDFData _vdfdata)
{
VDFNode newNode; //Declare our newNode type VDFNode variable which we will be used by our CreateNewNode to pass back our newly created VDFNode.
TreeNode newTreeNode = CreateNewNode(Name, _vdfdata, null, out newNode); //Call the method which will do the job of creating a TreeNode and VDFNode for us.
if (_vdfdata.Nodes == null)
{
throw new NullReferenceException("Nodes list of VDFData class is set to null!");
}
_vdfdata.Nodes.Add(newNode);
tViewData.Nodes.Add(newTreeNode);
return(newTreeNode);
}
TreeNode AddNodeToNode(string Name, TreeNode Parent, VDFData parentVDFDataStructure, VDFNode nodeParent)
{
VDFNode newNode; //Declare our newNode type VDFNode variable which we will be used by our CreateNewNode to pass back our newly created VDFNode.
TreeNode newTreeNode = CreateNewNode(Name, parentVDFDataStructure, nodeParent, out newNode); //Call the method which will do the job of creating a TreeNode and VDFNode for us.
if (nodeParent.Nodes == null)
{
throw new NullReferenceException("Nodes list of VDFData class is set to null!");
}
nodeParent.Nodes.Add(newNode);
Parent.Nodes.Add(newTreeNode);
return(newTreeNode);
}
void LoadVDFDataToTreeView(VDFData _vdfdata)
{
tViewData.Nodes.Clear();
if (_vdfdata.Nodes != null)
{
foreach (VDFNode vNode in _vdfdata.Nodes)
{
LoadVDFNodeToTreeView(vNode);
}
}
if (tViewData.Nodes.Count > 0) //Make sure to expand our first node if it exists.
{
tViewData.Nodes[0].Expand();
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
//check steam running
//while (!CheckSteamProcess())
// MessageBox.Show("Steam app must be closed");
//get steam users
var userdatapath = Path.Combine(Settings.SteamInstallPath, "userdata");
var users = new Dictionary <string, string>();
var localconfigs = new Dictionary <string, VDFNode>();
foreach (var userdirpath in Directory.GetDirectories(userdatapath, "*", SearchOption.TopDirectoryOnly))
{
var userid = Path.GetFileName(userdirpath);
var localconfig = new VDFData(File.ReadAllText(Path.Combine(userdirpath, "config", "localconfig.vdf")), false).Nodes[0];
localconfigs.Add(userid, localconfig);
var username = "******";
try { username = localconfig.Node("friends").Node(userid).Key("name"); } catch { }
users.Add(userid, username);
}
switch (users.Count)
{
case 0: MessageBox.Show("Steam users not found"); Close(); break;
case 1: _userId = users.Keys.First(); break;
default:
var suw = new SelectUserWindow(users);
suw.ShowDialog();
if (string.IsNullOrEmpty(suw.SelectedUser))
{
Close();
}
_userId = suw.SelectedUser;
break;
}
_localConfig = localconfigs[_userId];
_steamUser = new SteamUser(_userId);
_steamUser.UpdateAppsFromWeb();
_steamUser.UpdateAppsFromSharedConfig();
DataContext = _steamUser;
}
/// <summary>
/// Initializes the SteamApp class.
/// </summary>
/// <param name="vdfdata">The parsed VDF Data Structure.</param>
/// <param name="LibPath">The path of the library containing the application.</param>
void init(VDFData vdfdata, string LibPath)
{
if (vdfdata == null)
{
throw new ArgumentNullException("Argument VDF Data is set to null!");
}
if (vdfdata.Nodes == null || vdfdata.Nodes.Count == 0)
{
throw new NullReferenceException("Nodes of VDFData is either null or empty!");
}
_unparsedData = vdfdata;
VDFNode vNode = vdfdata.Nodes.FindNode(MANIFEST_NODE); //Locate our root node. We can do nodes[0] as well and it'll be faster but just to be safe.
if (vNode == null)
{
throw new NullReferenceException("Node " + MANIFEST_NODE + " is not found!");
}
if (vNode.Keys == null || vNode.Keys.Count == 0)
{
throw new NullReferenceException("Node " + MANIFEST_NODE + " list of keys is either null or empty!");
}
VDFKey vKey = vNode.Keys.FindKey(MANIFEST_KEY_NAME); //Locate our first key which will be the name of the app.
if (vKey != null)
{
_Name = vKey.Value;
}
else
{
throw new NullReferenceException("Key pertaining to the name of the app is not found under " + MANIFEST_NODE + " node.");
}
vKey = vNode.Keys.FindKey(MANIFEST_KEY_APPID);
if (vKey != null)
{
int tryresult;
if (int.TryParse(vKey.Value, out tryresult))
{
_AppID = tryresult;
}
else
{
throw new NullReferenceException("Key pertaining to the Application ID of the app under " + MANIFEST_NODE + " node is invalid!");
}
}
else
{
throw new NullReferenceException("Key pertaining to the Application ID of the app is not found under " + MANIFEST_NODE + " node.");
}
vKey = vNode.Keys.FindKey(MANIFEST_KEY_INSDIR);
if (vKey != null)
{
_InstallDir = LibPath + "\\" + SteamAppsManager.STEAM_APPS_DIRNAME + "\\" + SteamAppsManager.STEAM_APPS_COMMON_DIRNAME + "\\" + vKey.Value;
_InstallDirName = vKey.Value;
}
else
{
throw new NullReferenceException("Key pertaining to the directory name containing the app under " + MANIFEST_NODE + " node is not found!");
}
}
/// <summary>
/// Creates a SteamApp Class instance by parsing the VDF Data Structure in a Manifest file.
/// </summary>
/// <param name="ManifestPath">The path to the Application Manifest file.</param>
/// <param name="LibPath">The path of the library containing the application.</param>
public SteamApp(string ManifestPath, string LibPath)
{
VDFData vData = new VDFData(ManifestPath);
init(vData, LibPath);
}
/// <summary>
/// Creates a SteamApp Class instance using an already parsed VDF Data Structure.
/// </summary>
/// <param name="parsedmanifest">The parsed VDF Data Structure.</param>
/// <param name="LibPath">The path of the library containing the application.</param>
public SteamApp(VDFData parsedmanifest, string LibPath)
{
init(parsedmanifest, LibPath);
}
