/// <summary>
/// Imports a mod to the current selected KSP install path.
/// </summary>
/// <param name="importInfo">The ImportInfo </param>
/// <param name="copyDest">Flag to determine if the destination should be copied or if the auto destination detection should be used.</param>
/// <param name="addOnly">Flag to determine if the mod should be installed or only added to the ModSelection.</param>
private static void ImportMod(ImportInfo importInfo, bool copyDest, bool addOnly)
{
ModInfo modInfo = importInfo.ModInfo;
ModNode addedMod = ModSelectionController.AddMods(new ModInfo[] { modInfo }, false).FirstOrDefault();
if (addedMod != null)
{
if (copyDest)
{
// remove all destinations and uncheck all nodes.
ModNodeHandler.SetDestinationPaths(addedMod, string.Empty);
addedMod._Checked = false;
// copy destination
UpdateMessage(string.Format(Messages.MSG_COPY_MOD_DESTINATION_0, addedMod.Name));
if (!ModNodeHandler.TryCopyDestToMatchingNodes(importInfo, addedMod))
{
UpdateMessage(string.Format(Messages.MSG_COPY_MOD_0_DESTINATION_FAILED, addedMod.Name));
UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo);
return;
}
}
// install the mod.
if (!addOnly)
{
UpdateMessage(string.Format(Messages.MSG_INSTALLING_MOD_0, addedMod.Name));
ModSelectionController.ProcessMods(new ModNode[] { addedMod });
}
}
else
{
UpdateMessage(string.Format(Messages.MSG_IMPORT_0_FAILED, importInfo.Name), importInfo);
}
}
/// <summary>
/// Handles a mod add via URL.
/// Validates the URL, gets ModInfos, downloads mod archive, adds it to the ModSelection and installs the mod if selected.
/// </summary>
/// <param name="url">The URL to the mod.</param>
/// <param name="modName">The name for the mod.</param>
/// <param name="install">Flag to determine if the mod should be installed after adding.</param>
/// <param name="downloadProgressCallback">Callback function for download progress.</param>
/// <returns>The root node of the added mod, or null.</returns>
public ModNode HandleAdd(string url, string modName, bool install, DownloadProgressCallback downloadProgressCallback = null)
{
url = ReduceToPlainUrl(url);
ModInfo modInfo = GetModInfo(url);
if (modInfo == null)
{
return(null);
}
if (!string.IsNullOrEmpty(modName))
{
modInfo.Name = modName;
}
ModNode newMod = null;
if (DownloadMod(ref modInfo, downloadProgressCallback))
{
newMod = ModSelectionController.HandleModAddViaModInfo(modInfo, install);
}
return(newMod);
}
/// <summary>
/// Creates a XmlNode for the child nodes of the mod.
/// </summary>
/// <param name="doc">The XmlDocument for XmlNode creation.</param>
/// <param name="mod">The mod node to get the information for the XMLNode.</param>
/// <returns>A XmlNode with the infos from the mod.</returns>
private static XmlNode CreateModChildEntryXmlNode(XmlDocument doc, ModNode mod)
{
XmlNode modEntryNode = doc.CreateElement(Constants.MOD_ENTRY);
XmlAttribute nodeAttribute = doc.CreateAttribute(Constants.NAME);
nodeAttribute.Value = mod.Text;
modEntryNode.Attributes.Append(nodeAttribute);
nodeAttribute = doc.CreateAttribute(Constants.ISFILE);
nodeAttribute.Value = mod.IsFile ? ONE : ZERO;
modEntryNode.Attributes.Append(nodeAttribute);
nodeAttribute = doc.CreateAttribute(Constants.INSTALL);
nodeAttribute.Value = mod.IsInstalled ? ONE : ZERO;
modEntryNode.Attributes.Append(nodeAttribute);
nodeAttribute = doc.CreateAttribute(Constants.INSTALLDIR);
nodeAttribute.Value = mod.Destination;
modEntryNode.Attributes.Append(nodeAttribute);
foreach (ModNode child in mod.Nodes)
{
modEntryNode.AppendChild(CreateModChildEntryXmlNode(doc, child));
}
return(modEntryNode);
}
private void OpenFolder(ModNode node)
{
if (node != null && !node.IsFile && node.IsInstalled)
{
OptionsController.OpenFolder(KSPPathHelper.GetAbsolutePath(SelectedNode.Destination));
}
}
private void OpenFile(ModNode node)
{
if (node != null && node.IsFile)
{
ModSelectionController.OpenTextDisplayer(node);
}
}
/// <summary>
/// Returns all colliding mods (ZipRoots) that collides with the passed mod.
/// </summary>
/// <param name="modNode">The mod to get the collision mods for.</param>
/// <returns>All colliding mods (ZipRoots) that collides with the passed mod.</returns>
public static List <ModNode> GetCollisionModsByCollisionMod(ModNode modNode)
{
List <ModNode> result = new List <ModNode>();
if (!ConflictDetectionOnOff)
{
return(result);
}
foreach (var fileNode in modNode.ZipRoot.GetAllFileNodes())
{
if (mRegisterdModFiles.ContainsKey(fileNode.Destination.ToLower()))
{
foreach (var regFileNode in mRegisterdModFiles[fileNode.Destination.ToLower()])
{
if (regFileNode != modNode && !result.Contains(regFileNode.ZipRoot))
{
result.Add(regFileNode.ZipRoot);
}
}
}
}
return(result);
}
/// <summary>
/// Returns a flat list of all colliding modNodes for all fileNodes of the passed node.
/// </summary>
/// <returns>A flat list of all colliding modNodes for all fileNodes of the passed node.</returns>
public static List <ModNode> GetCollisionModFiles(ModNode modNode)
{
List <ModNode> result = new List <ModNode>();
if (!ConflictDetectionOnOff)
{
return(result);
}
if (modNode.IsFile)
{
if (mRegisterdModFiles.ContainsKey(modNode.Destination.ToLower()))
{
result.AddRange(mRegisterdModFiles[modNode.Destination.ToLower()].Where(node => node != modNode));
}
}
else
{
foreach (var fileNode in modNode.ZipRoot.GetAllFileNodes())
{
if (mRegisterdModFiles.ContainsKey(fileNode.Destination.ToLower()))
{
result.AddRange(mRegisterdModFiles[fileNode.Destination.ToLower()].Where(regFileNode => regFileNode != modNode));
}
}
}
return(result);
}
/// <summary>
/// Solves the destination collision for a Mod.
/// Removes the destination of all mod files registered to the destination of
/// </summary>
/// <param name="modRoot">The mod to keep the destination.</param>
public static void SolveCollisions(ModNode modRoot)
{
var collidingNodes = GetAllCollisionNodes(modRoot);
foreach (ModNode collidingNode in collidingNodes)
{
if (string.IsNullOrEmpty(collidingNode.Destination) || !mRegisterdModFiles.ContainsKey(collidingNode.Destination.ToLower()))
{
collidingNode.HasCollision = false;
continue;
}
List <ModNode> removeDestinationNodes = mRegisterdModFiles[collidingNode.Destination.ToLower()].Where(node => node != collidingNode).ToList();
foreach (ModNode delNode in removeDestinationNodes)
{
RemoveRegisteredModFile(delNode);
// TODO:
////TreeViewEx.ChangeCheckedState(delNode, false, true, true);
if (!delNode.IsFile && delNode.IsInstalled)
{
ModSelectionController.ProcessMods(new ModNode[] { delNode }, true);
}
delNode.SetDestinationPaths(string.Empty);
}
}
}
/// <summary>
/// Creates a directory for the ModNodes destination.
/// </summary>
/// <param name="node">The ModNode to get the destination of.</param>
/// <param name="silent">Determines if info messages should be added displayed.</param>
private static void CreateDirectory(ModNode node, bool silent)
{
string destination = node.Destination;
if (!string.IsNullOrEmpty(destination))
{
destination = KSPPathHelper.GetAbsolutePath(destination);
}
node.IsInstalled = false;
if (!Directory.Exists(destination))
{
try
{
Directory.CreateDirectory(destination);
node.IsInstalled = true;
if (!silent)
{
Messenger.AddInfo(string.Format(Messages.MSG_DIR_CREATED_0, destination));
}
}
catch
{
Messenger.AddInfo(string.Format(Messages.MSG_DIR_CREATED_ERROR_0, destination));
}
}
node.NodeType = (node.IsKSPFolder) ? NodeType.KSPFolderInstalled : NodeType.UnknownFolderInstalled;
}
/// <summary>
/// Removes the file the ModNodes destination points to.
/// </summary>
/// <param name="node">The ModNode to get the destination of.</param>
/// <param name="silent">Determines if info messages should be added displayed.</param>
private static void RemoveFile(ModNode node, bool silent)
{
string destination = node.Destination;
if (!string.IsNullOrEmpty(destination))
{
destination = KSPPathHelper.GetAbsolutePath(destination);
}
node.IsInstalled = false;
bool installedByOtherMod = ModRegister.GetCollisionModFiles(node).Any(n => n.IsInstalled);
if (File.Exists(destination) && !installedByOtherMod)
{
try
{
File.Delete(destination);
node.IsInstalled = false;
if (!silent)
{
Messenger.AddInfo(string.Format(Messages.MSG_FILE_DELETED_0, destination));
}
}
catch (Exception ex)
{
Messenger.AddError(string.Format(Messages.MSG_FILE_DELETED_ERROR_0, destination), ex);
}
}
node.NodeType = NodeType.UnknownFile;
}
/// <summary>
/// Processes all passed nodes. (Adds/Removes the MOD to/from the KSP install folders).
/// </summary>
/// <param name="modArray">The NodeArray to process.</param>
/// <param name="processedNodeCount">For internal use only!</param>
/// <param name="silent">Determines if info messages should be added displayed.</param>
/// <param name="overrideOn">Flag to set override of files on.</param>
/// <param name="progressChanged">Callback function when the progress of the processing changed.</param>
/// <returns>Count of processed nodes.</returns>
private static int ProcessNodes(ModNode[] modArray, ref int processedNodeCount, bool silent = false, bool overrideOn = false, AsyncProgressChangedHandler progressChanged = null)
{
foreach (ModNode node in modArray)
{
if (node.HasDestination)
{
if (!silent)
{
Messenger.AddInfo(string.Format(Messages.MSG_ROOT_IDENTIFIED, node.Text));
}
ProcessNode(node, ref processedNodeCount, silent, overrideOn, progressChanged);
}
else if (node.HasDestinationForChilds)
{
if (progressChanged != null)
{
progressChanged(processedNodeCount += 1);
}
ModNode[] nodes = new ModNode[node.Nodes.Count];
for (int i = 0; i < node.Nodes.Count; ++i)
{
nodes[i] = (ModNode)node.Nodes[i];
}
ProcessNodes(nodes, ref processedNodeCount, silent, overrideOn, progressChanged);
}
}
return(processedNodeCount);
}
/// <summary>
/// Processes all passed nodes. (Adds/Removes the MOD to/from the KSP install folders).
/// </summary>
/// <param name="mod">The mod to process.</param>
/// <param name="silent">Determines if info messages should be added displayed.</param>
/// <param name="overrideOn">Flag to set override of files on.</param>
/// <param name="progressChanged">Callback function when the progress of the processing changed.</param>
/// <returns>Count of processed nodes.</returns>
public static int ProcessMod(ModNode mod, bool silent = false, bool overrideOn = false, AsyncProgressChangedHandler progressChanged = null, int processedNodeCount = 0)
{
if (!silent)
{
Messenger.AddInfo(Constants.SEPARATOR);
Messenger.AddInfo(string.Format(Messages.MSG_START_PROCESSING_0, mod.Name));
Messenger.AddInfo(Constants.SEPARATOR);
}
int processedNode = processedNodeCount;
try
{
processedNode = ProcessNodes(new ModNode[] { mod }, ref processedNode, silent, overrideOn, progressChanged);
}
catch (Exception ex)
{
Messenger.AddError(string.Format(Messages.MSG_ERROR_DURING_PROCESSING_MOD_0, mod.Name), ex);
}
DeleteNotProcessedDirectorys(silent);
if (!silent)
{
Messenger.AddInfo(Constants.SEPARATOR);
}
return(processedNode);
}
/// <summary>
/// Removes the mod file from the registration.
/// </summary>
/// <param name="fileNode">The file node to unregister.</param>
public static void RemoveRegisteredModFile(ModNode fileNode)
{
if (!string.IsNullOrEmpty(fileNode.Destination) && mRegisterdModFiles.ContainsKey(fileNode.Destination.ToLower()) &&
mRegisterdModFiles[fileNode.Destination.ToLower()].Contains(fileNode))
{
mRegisterdModFiles[fileNode.Destination.ToLower()].Remove(fileNode);
fileNode.HasCollision = false;
if (mRegisterdModFiles[fileNode.Destination.ToLower()].Count == 0)
{
mRegisterdModFiles.Remove(fileNode.Destination.ToLower());
}
else if (mRegisterdModFiles[fileNode.Destination.ToLower()].Count == 1)
{
mRegisterdModFiles[fileNode.Destination.ToLower()][0].HasCollision = false;
}
else if (mRegisterdModFiles[fileNode.Destination.ToLower()].Count > 1)
{
if (HaveCollisionsSameRoot(fileNode))
{
mRegisterdModFiles[fileNode.Destination.ToLower()][0].HasCollision = false;
}
}
}
}
/// <summary>
/// Loads the config.
/// </summary>
public static void Load(string path, ref List <ModNode> modNodes)
{
ModNode root = new ModNode()
{
Key = Constants.ROOT
};
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNodeList moVersion = doc.GetElementsByTagName(Constants.VERSION);
if (moVersion.Count > 0)
{
switch (moVersion[0].InnerText.ToLower())
{
case "v1.0":
root = LoadV1_0(doc);
break;
}
}
}
catch (Exception ex)
{
Messenger.AddError(string.Format("Error during KSPMods.cfg. \"{0}\"", ex.Message), ex);
}
modNodes.AddRange(root.Nodes.Cast <ModNode>());
}
private ExpressionNode ParseTerm()
{
var lhs = ParseUnary();
while (true)
{
if (_reader.Peek() is Asterisk)
{
Match <Asterisk>();
lhs = new MultiplicationNode(lhs, ParseUnary());
}
else if (_reader.Peek() is Slash)
{
Match <Slash>();
lhs = new DivisionNode(lhs, ParseUnary());
}
else if (_reader.Peek() is Percent)
{
Match <Percent>();
lhs = new ModNode(lhs, ParseUnary());
}
else
{
break;
}
}
return(lhs);
}
/// <summary>
/// Creates a zip for each root node in the passed node list.
/// </summary>
/// <param name="nodes">List of root nodes to create zips for.</param>
/// <param name="filePath">the path (folder) where the new Zip should be saved to.</param>
/// <returns>True on success.</returns>
public static bool CreateZip(List <ModNode> nodes, string filePath)
{
// create the zip
List <string> done = new List <string>();
foreach (ModNode node in nodes)
{
ModNode root = node.ZipRoot;
if (root != null && !File.Exists(root.LocalPath) && !done.Contains(root.LocalPath))
{
string zipPath = Path.Combine(filePath, Path.GetFileNameWithoutExtension(root.Name) + Constants.EXT_ZIP);
using (var zip = ZipArchive.Create())
{
int nodecount = 0;
foreach (ModNode child in root.Nodes)
{
nodecount = CreateZipEntry(zip, child, nodecount);
}
zip.SaveTo(zipPath, CompressionType.None);
}
Messenger.AddInfo(string.Format(Messages.MSG_ZIP_0_CREATED, root.Name));
done.Add(root.Name);
root.Key = zipPath;
}
}
return(true);
}
/*multiplicative-expression-p:
| multiplicative-operators unary-expression multiplicative-expression-p
| EPSILON */
private ExpressionNode multiplicative_expression_p(ExpressionNode leftExpression)
{
printIfDebug("multiplicative_expression_p");
if (pass(multiplicativeOperatorOptions))
{
Token multiplicativeOperator = token;
consumeToken();
var unaryExpression = unary_expression();
ExpressionNode resultExpression = null;
if (multiplicativeOperator.type == TokenType.OP_MULTIPLICATION)
{
resultExpression = new MultNode(leftExpression, unaryExpression, multiplicativeOperator);
}
else if (multiplicativeOperator.type == TokenType.OP_DIVISION)
{
resultExpression = new DivNode(leftExpression, unaryExpression, multiplicativeOperator);
}
else
{
resultExpression = new ModNode(leftExpression, unaryExpression, multiplicativeOperator);
}
return(multiplicative_expression_p(resultExpression));
}
return(leftExpression);
}
/// <summary>
/// Removes the registered mod files of a mod.
/// </summary>
/// <param name="modRoot">The root node of the mod from which the files should be unregistered.</param>
public static void RemoveRegisteredMod(ModNode modRoot)
{
RemoveRegisteredModFile(modRoot);
foreach (ModNode child in modRoot.Nodes)
{
RemoveRegisteredMod(child);
}
}
/// <summary>
/// Handles a mod add via URL.
/// Validates the URL, gets ModInfos, downloads mod archive, adds it to the ModSelection and installs the mod if selected.
/// </summary>
/// <param name="url">The URL to the mod.</param>
/// <param name="modName">The name for the mod.</param>
/// <param name="install">Flag to determine if the mod should be installed after adding.</param>
/// <param name="downloadProgressCallback">Callback function for download progress.</param>
/// <returns>The root node of the added mod, or null.</returns>
public ModNode HandleAdd(string url, string modName, bool install, DownloadProgressCallback downloadProgressCallback = null)
{
ISiteHandler curseForge = SiteHandlerManager.GetSiteHandlerByName("CurseForge");
ModNode modNode = curseForge.HandleAdd(GetDownloadURL(url), modName, install, downloadProgressCallback);
////modNode.VersionControllerName = Name;
return(modNode);
}
/// <summary>
/// Returns the destination path of the craft.
/// </summary>
/// <param name="craftNode">The craft to get the destination for.</param>
public static void SetCraftDestination(ModNode craftNode)
{
string zipPath = craftNode.ZipRoot.Key;
using (IArchive archive = ArchiveFactory.Open(zipPath))
{
foreach (IArchiveEntry entry in archive.Entries)
{
if (!entry.FilePath.EndsWith(craftNode.Text, StringComparison.CurrentCultureIgnoreCase))
{
continue;
}
using (MemoryStream ms = new MemoryStream())
{
entry.WriteTo(ms);
ms.Position = 0;
using (StreamReader sr = new StreamReader(ms))
{
string fullText = sr.ReadToEnd();
int index = fullText.IndexOf(TYPE);
if (index == -1)
{
continue;
}
string filename = Path.GetFileName(entry.FilePath);
if (string.IsNullOrEmpty(filename))
{
continue;
}
string shipType = fullText.Substring(index + 7, 3);
if (shipType.Equals(Constants.SPH, StringComparison.CurrentCultureIgnoreCase))
{
craftNode.Destination = Path.Combine(KSPPathHelper.GetPath(KSPPaths.SPH), filename);
}
else
{
craftNode.Destination = Path.Combine(KSPPathHelper.GetPath(KSPPaths.VAB), filename);
}
if (!string.IsNullOrEmpty(craftNode.Destination))
{
craftNode.Destination = KSPPathHelper.GetRelativePath(craftNode.Destination);
}
SetToolTips(craftNode);
break;
}
}
}
}
}
private void cmsModSelectionOneMod_Opened(object sender, EventArgs e)
{
int selectedModCount = SelectedMods.Count;
ModNode selectedNode = SelectedNode;
if (HasSelectedNode)
{
if (selectedModCount != 1)
{
tsmiCmsDestinationPath.Text = "<" + Messages.MSG_NOT_AVAILABLE + ">";
}
else
{
tsmiCmsDestinationPath.Text = string.IsNullOrEmpty(selectedNode.Destination) ? "<" + Messages.MSG_NO_DESTINATION + ">" : selectedNode.Destination;
}
tsmiCmsSelectNewDestination.Enabled = (selectedModCount == 1);
tsmiCmsResetDestination.Enabled = (selectedModCount == 1);
tsmiCmsRedetectDestination.Enabled = (selectedModCount == 1);
tsmiCmsRefreschCheckedState.Visible = (selectedModCount == 1);
tsmiCmsRefreshCheckedStateForHighlightedMods.Visible = !tsmiCmsRefreschCheckedState.Visible;
tsmiCmsEditModInfos.Enabled = (selectedModCount == 1);
tsmiCmsCopyModInfos.Enabled = (selectedModCount == 1);
tsmiCmsUpdatecheckMod.Visible = (selectedModCount == 1);
tsmiCmsCheckHighlightedModsForUpdates.Visible = !tsmiCmsUpdatecheckMod.Visible;
tsmiUpdateMod.Visible = (selectedModCount == 1);
tsmiUpdateHiglightedMods.Visible = !tsmiUpdateMod.Visible;
tsmiCmsVisitVersionControlSite.Enabled = !string.IsNullOrEmpty(selectedNode.ZipRoot.ModURL);
tsmiCmsVisitAdditionalLink.Enabled = !string.IsNullOrEmpty(selectedNode.ZipRoot.AdditionalURL);
tsmiCmsRemoveMod.Visible = (selectedModCount == 1);
tsmiCmsRemoveHighlightedMods.Visible = !tsmiCmsRemoveMod.Visible;
tsmiCmsProceedMod.Visible = (selectedModCount == 1);
tsmiCmsProceedHighlightedMods.Visible = !tsmiCmsProceedMod.Visible;
tsmiCmsCreateZip.Enabled = !selectedNode.ZipExists;
tsmiCmsOneModOpenFile.Visible = selectedNode.IsFile;
tsmiCmsOneModOpenFolder.Visible = !selectedNode.IsFile && selectedNode.IsInstalled;
tsmiCmsSolveConflicts.Enabled = ModRegister.HasConflicts;
}
if (tvModSelection.SelectedNodes.Count > 1)
{
tsmiCmsDestinationPath.Text = "<" + Messages.MSG_NOT_AVAILABLE + ">";
tsmiCmsSelectNewDestination.Enabled = false;
tsmiCmsRedetectDestination.Enabled = false;
tsmiCmsResetDestination.Visible = false;
tsmiCmsResetDestinations.Visible = true;
tsmiCmsOneModOpenFile.Visible = false;
tsmiCmsOneModOpenFolder.Visible = false;
}
else
{
tsmiCmsResetDestination.Visible = true;
tsmiCmsResetDestinations.Visible = false;
}
}
/// <summary>
/// Sets the ToolTip text of the node and all its childes.
/// </summary>
/// <param name="node">The node to set the ToolTip to.</param>
public static void SetToolTips(ModNode node)
{
// TODO:!!!
////if (node.Destination != string.Empty)
//// node.ToolTipText = node.Destination.ToLower().Replace(MainForm.GetPath(KSP_Paths.KSP_Root).ToLower(), "KSP install folder");
////else
//// node.ToolTipText = "<No path selected>";
////foreach (TreeNodeMod child in node.Nodes)
//// SetToolTips(child);
}
/// <summary>
/// Returns the absolute path of the ModNode.
/// </summary>
/// <param name="node">The ModNode to get the absolute path from.</param>
/// <returns>The absolute path of the ModNode.</returns>
public static string GetAbsolutePath(ModNode node)
{
if (node.HasDestination)
{
return(GetAbsolutePath(node.Destination));
}
else
{
return(string.Empty);
}
}
/// <summary>
/// Creates a TreeNode.
/// </summary>
/// <param name="filename">Zip-File path</param>
/// <param name="parent">The parent node where the created node will be attached attach to.</param>
/// <param name="pathSeperator">The separator character used within the filename.</param>
/// <param name="isDirectory">Flag that indicates if entry is a directory entry or not.</param>
/// <param name="silent">Determines if info messages should be added.</param>
private static void CreateModNode(string filename, ModNode parent, char pathSeperator, bool isDirectory, bool silent = false)
{
// ignore directory entries.
if (!isDirectory)
{
HandleFileEntry(filename, parent, pathSeperator, silent);
}
else
{
ModNode node = CreateNeededDirNodes(filename + "fake.file", parent, pathSeperator);
}
}
/// <summary>
/// Checks the node and all child nodes that have a destination.
/// </summary>
/// <param name="node">The node to check.</param>
public static void CheckNodesWithDestination(ModNode node)
{
if (node.HasDestination)
{
CheckNodeAndParents(node);
}
foreach (ModNode child in node.Nodes)
{
CheckNodesWithDestination(child);
}
}
/// <summary>
/// Finds the root folder of the mod that can be installed to the KSP install folder.
/// </summary>
/// <param name="node">Node to start the search from.</param>
/// <returns>The root folder of the mod that can be installed to the KSP install folder.</returns>
private static bool FindAndSetDestinationPaths(ModNode node)
{
List <ModNode> kspFolders = new List <ModNode>();
List <ModNode> craftFiles = new List <ModNode>();
ModSelectionTreeModel.GetAllKSPFolders(node, ref kspFolders, ref craftFiles);
if (kspFolders.Count == 1)
{
SetDestinationPaths(kspFolders[0], false);
}
else if (kspFolders.Count > 1)
{
kspFolders.Sort((node1, node2) =>
{
if (node2.Depth == node1.Depth)
{
return(node1.Text.CompareTo(node2.Text));
}
else
{
return(node2.Depth - node1.Depth);
}
});
bool lastResult = false;
foreach (ModNode kspFolder in kspFolders)
{
lastResult = SetDestinationPaths(kspFolder, lastResult);
}
}
if (craftFiles.Count > 0)
{
foreach (ModNode craftNode in craftFiles)
{
string vab = KSPPathHelper.GetPath(KSPPaths.VAB);
string sph = KSPPathHelper.GetPath(KSPPaths.SPH);
if (!craftNode.HasDestination || (!craftNode.Destination.StartsWith(vab, StringComparison.CurrentCultureIgnoreCase) &&
!craftNode.Destination.StartsWith(sph, StringComparison.CurrentCultureIgnoreCase)))
{
SetCraftDestination(craftNode);
}
}
}
if (node.HasDestination || node.HasDestinationForChilds)
{
node.SetChecked(true);
}
return((kspFolders.Count > 0) || (craftFiles.Count > 0));
}
/// <summary>
/// Handles and creates a file entry.
/// </summary>
/// <param name="filename">Zip-File path</param>
/// <param name="parent">The parent node where the created node will be attached attach to.</param>
/// <param name="pathSeperator">The separator character used within the filename.</param>
/// <param name="silent">Determines if info messages should be added.</param>
private static void HandleFileEntry(string filename, ModNode parent, char pathSeperator, bool silent = false)
{
// plain filename?
if (!filename.Contains(pathSeperator))
{
CreateFileListEntry(filename, parent, silent);
}
else // filename with dir(s) infront
{
ModNode node = CreateNeededDirNodes(filename, parent, pathSeperator);
CreateFileListEntry(filename, node, silent);
}
}
/// <summary>
/// Creates a file entry for the TreeView.
/// </summary>
/// <param name="fileName">Zip-File path of the file.</param>
/// <param name="parent">The parent node where the created node will be attached attach to.</param>
/// <param name="silent">Determines if info messages should be added.</param>
private static void CreateFileListEntry(string fileName, ModNode parent, bool silent = false)
{
ModNode node = new ModNode(fileName, Path.GetFileName(fileName), NodeType.UnknownFile);
// TODO:!!!
////node.ToolTipText = "<No path selected>";
parent.Nodes.Add(node);
if (!silent)
{
Messenger.AddInfo(string.Format(Messages.MSG_FILE_ADDED_0, fileName));
}
}
/// <summary>
/// Registers all mod files that have a destination.
/// </summary>
/// <param name="modRoot">The root node of the mod to register the file nodes from.</param>
/// <returns>True if a collision with another mod was detected.</returns>
public static bool RegisterMod(ModNode modRoot)
{
bool collisionDetected = false;
List <ModNode> fileNodes = GetAllNodesWithDestination(modRoot);
foreach (ModNode fileNode in fileNodes)
{
if (RegisterModFile(fileNode))
{
collisionDetected = true;
}
}
return(collisionDetected);
}
/// <summary>
/// Adds a source folder to the CB_Source for the passed node and all its childs.
/// </summary>
/// <param name="node">The node to add as source folder.</param>
/// <param name="depth">The depth of the recursive call.</param>
/// <note>Recursive function!</note>
private void AddSrcFolder(ModNode node, int depth = 0)
{
if (!cbListFoldersOnly.Checked || (cbListFoldersOnly.Checked && !node.IsFile))
{
CB_Source.Items.Add(node);
}
foreach (ModNode child in node.Nodes)
{
if (!cbListFoldersOnly.Checked || (cbListFoldersOnly.Checked && !child.IsFile))
{
AddSrcFolder(child, depth + 1);
}
}
}
