public static void removeNodeStructure(NodeStructure nodeStructure, NodeStructureList nodeStructureList)
{
for (int i = 0; i < nodeStructureList.Count; i++)
{
if (nodeStructureList[i].name == nodeStructure.name)
{
nodeStructureList.RemoveAt(i);
}
}
nodeStructureList = NodeStructureListManager.alphabetize(nodeStructureList);
nodeStructureList = NodeStructureListManager.reindex(nodeStructureList);
}
public static void addNodeStructure(NodeStructure nodeStructure, NodeStructureList nodeStructureList)
{
nodeStructureList.Add(nodeStructure);
nodeStructureList = NodeStructureListManager.alphabetize(nodeStructureList);
nodeStructureList = NodeStructureListManager.reindex(nodeStructureList);
}
public static NodeStructureList getNewRequests(NodeStructureList nodeStructureList, TreeView treeView, string rootDirectory, bool isFresh, int occurance, TreeNode treeNode)
{
try
{
if (isFresh)
nodeStructureList = new NodeStructureList();
if (occurance == 1)
saveExpandedState(nodeStructureList, treeView);
string[] nodeStructures = System.IO.Directory.GetDirectories(rootDirectory);
NodeStructure nodeStructure = null, requestNodeStructure = null, nodeStructureFile = null;
string[] files = null;
int i = 0;
foreach (string nodeStructureString in nodeStructures)
{
nodeStructure = new NodeStructure();
nodeStructure.path = nodeStructureString;
nodeStructure.isParent = true;
NodeStructureManager.getName(nodeStructure, NodeStructureManager.getStructureType(nodeStructure));
if (!NodeStructureListManager.containsNodeStructure(nodeStructureList, nodeStructure))
{
NodeStructureListManager.addNodeStructure(nodeStructure, nodeStructureList);
}
else
{
nodeStructure = NodeStructureListManager.getNodeStructureWithName(nodeStructureList, nodeStructure.name);
nodeStructure.children = NodeStructureListManager.getNodeStructureWithName(nodeStructureList, nodeStructure.name).children;
NodeStructureManager.assignParentNames(nodeStructure);
}
string[] requestNodeStructures = System.IO.Directory.GetDirectories(nodeStructure.path + "\\Requests");
foreach (string requestNodeStructureString in requestNodeStructures)
{
requestNodeStructure = new NodeStructure();
requestNodeStructure.path = requestNodeStructureString;
requestNodeStructure.isChild = true;
requestNodeStructure.isParent = true;
NodeStructureManager.getName(requestNodeStructure, ENodeSructureType.BOTH);
if (!NodeStructureListManager.containsNodeStructure(nodeStructure.children, requestNodeStructure))
{
NodeStructureListManager.removeNodeStructure(nodeStructure, nodeStructureList);
NodeStructureManager.addChild(nodeStructure, requestNodeStructure);
NodeStructureListManager.addNodeStructure(nodeStructure, nodeStructureList);
}
else
{
requestNodeStructure = NodeStructureListManager.getNodeStructureWithName(nodeStructure.children, requestNodeStructure.name);
requestNodeStructure.children = NodeStructureListManager.getNodeStructureWithName(nodeStructure.children, requestNodeStructure.name).children;
NodeStructureManager.assignParentNames(requestNodeStructure);
}
files = System.IO.Directory.GetFiles(requestNodeStructure.path);
foreach (string file in files)
{
nodeStructureFile = new NodeStructure();
nodeStructureFile.path = file;
nodeStructureFile.isChild = true;
NodeStructureManager.getName(nodeStructureFile, NodeStructureManager.getStructureType(nodeStructureFile));
if (!NodeStructureListManager.containsNodeStructure(requestNodeStructure.children, nodeStructureFile))
{
NodeStructure node3 = requestNodeStructure;
NodeStructureListManager.removeNodeStructure(node3, nodeStructure.children);
NodeStructureManager.addChild(node3, nodeStructureFile);
NodeStructureManager.uncheck(nodeStructureList, node3, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
NodeStructureListManager.addNodeStructure(node3, nodeStructure.children);
requestNodeStructure = node3;
}
}
for (int h = 0; h < requestNodeStructure.children.Count; h++)
{
if (!files.Contains(requestNodeStructure.children[h].path))
{
NodeStructureListManager.removeNodeStructure(requestNodeStructure.children[h], requestNodeStructure.children);
if (NodeStructureManager.allChildrenChecked(requestNodeStructure))
NodeStructureManager.check(nodeStructureList, requestNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
}
requestNodeStructure.children = NodeStructureListManager.alphabetize(requestNodeStructure.children);
requestNodeStructure.children = NodeStructureListManager.reindex(requestNodeStructure.children);
requestNodeStructure.children = NodeStructureListManager.removeDuplicateNodes(requestNodeStructure.children);
}
for (int x = 0; x < nodeStructure.children.Count; x++)
{
if (!requestNodeStructures.Contains(nodeStructure.children[x].path))
NodeStructureListManager.removeNodeStructure(nodeStructure.children[x], nodeStructure.children);
}
nodeStructureList[i].children = NodeStructureListManager.alphabetize(nodeStructureList[i].children);
nodeStructureList[i].children = NodeStructureListManager.reindex(nodeStructureList[i].children);
nodeStructureList[i].children = NodeStructureListManager.removeDuplicateNodes(nodeStructureList[i].children);
i++;
}
for (int k = 0; k < nodeStructureList.Count; k++)
{
if (!nodeStructures.Contains(nodeStructureList[k].path))
NodeStructureListManager.removeNodeStructure(nodeStructureList[k], nodeStructureList);
}
nodeStructureList = NodeStructureListManager.alphabetize(nodeStructureList);
nodeStructureList = NodeStructureListManager.reindex(nodeStructureList);
nodeStructureList = NodeStructureListManager.removeDuplicateNodes(nodeStructureList);
return nodeStructureList;
}
catch (Exception)
{
MessageBox.Show("Error loading files. Please check directory formatting.");
Form1.Logger.Error("Error loading files. Please check directory formatting.");
Application.Exit();
return null;
}
}
public static void synchronize(EDifferenceToMake differenceToMake, NodeStructure nodeStructure, NodeStructureList nodeStructureList, TreeView treeView, ENodeStructureCheckedEntryPoint nodeStructureCheckedEntryPoint, TreeNode treeNode, int occurance)
{
switch (nodeStructureCheckedEntryPoint)
{
case (ENodeStructureCheckedEntryPoint)(0):
{
switch (differenceToMake)
{
case (EDifferenceToMake)(0):
{
nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.USER;
NodeStructureManager.check(nodeStructureList, nodeStructure, (ENodeStructureCheckedEntryPoint)(0));
break;
}
case (EDifferenceToMake)(1):
{
nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.USER;
NodeStructureManager.uncheck(nodeStructureList, nodeStructure, (ENodeStructureCheckedEntryPoint)(0));
break;
}
}
break;
}
case (ENodeStructureCheckedEntryPoint)(1):
{
switch (differenceToMake)
{
case (EDifferenceToMake)(0):
{
//nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.FORCED;
NodeStructureManager.uncheck(nodeStructureList, nodeStructure, (ENodeStructureCheckedEntryPoint)(1));
nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.USER;
break;
}
case (EDifferenceToMake)(1):
{
//nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.FORCED;
NodeStructureManager.check(nodeStructureList, nodeStructure, (ENodeStructureCheckedEntryPoint)(1));
nodeStructureCheckedEntryPoint = ENodeStructureCheckedEntryPoint.USER;
break;
}
}
break;
}
}
fillTreeView(nodeStructureList, treeView, treeNode, occurance);
}
public static EDifferenceToMake differencesExist(NodeStructure nodeStructure, TreeNode treeNode)
{
if (treeNode.Checked)
{
if (nodeStructure.isChecked == false)
{
return (EDifferenceToMake)(0);
}
else
return (EDifferenceToMake)(2);
}
else if (!treeNode.Checked)
{
if (nodeStructure.isChecked == true)
{
return (EDifferenceToMake)(1);
}
else
return (EDifferenceToMake)(2);
}
else
return (EDifferenceToMake)(2);
}
public static void check(NodeStructureList nodeStructureList, NodeStructure nodeStructure, ENodeStructureCheckedEntryPoint nodeStructureCheckedEntryPoint)
{
if (nodeStructure.isChild)
{
NodeStructure parent = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
NodeStructureListManager.removeNodeStructure(nodeStructure, parent.children);
nodeStructure.isChecked = true;
NodeStructureListManager.addNodeStructure(nodeStructure, parent.children);
if (nodeStructure.isParent)
{
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYPARENT)
{
for (int i = 0; i < nodeStructure.children.Count; i++)
{
check(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYCHILD)
{
//Maybe check parent.
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
if (NodeStructureManager.allChildrenChecked(parentNodeStructure))
check(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER) {
//Do both of the above.
for (int i = 0; i < nodeStructure.children.Count; i++)
{
check(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
if (NodeStructureManager.allChildrenChecked(parentNodeStructure))
check(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
}
else
{
//Just a child that was selected.
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER)
{
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
if (NodeStructureManager.allChildrenChecked(parentNodeStructure))
check(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYPARENT)
{
//Do nothing...last level.
}
}
}
else if (nodeStructure.isParent)
{
nodeStructure.isChecked = true;
//Just a parent - top level
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYPARENT)
{
//Impossible.
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYCHILD)
{
//Done - no more.
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER)
{
for (int i = 0; i < nodeStructure.children.Count; i++)
{
check(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
}
}
}
public static void addChild(NodeStructure parentNodeStructure, NodeStructure childNodeStructure)
{
NodeStructureListManager.addNodeStructure(childNodeStructure, parentNodeStructure.children);
childNodeStructure.parentName = parentNodeStructure.name;
}
public static bool allChildrenChecked(NodeStructure parentNodeStructure)
{
//Precondition: parentNodeStructure is a parent
foreach (NodeStructure childNodeStructure in parentNodeStructure.children) {
if (!childNodeStructure.isChecked)
return false;
}
return true;
}
public static void addPath(NodeStructure nodeStructure, string path)
{
nodeStructure.path = path;
}
public static void assignParentNames(NodeStructure parentNodeStructure)
{
for (int i = 0; i < parentNodeStructure.children.Count; i++)
{
parentNodeStructure.children[i].parentName = parentNodeStructure.name;
}
}
public static ENodeSructureType getStructureType(NodeStructure nodeStructure)
{
if (nodeStructure.isParent && nodeStructure.isChild)
{
return (ENodeSructureType)2;
}
else if (nodeStructure.isParent)
{
return (ENodeSructureType)0;
}
else if (nodeStructure.isChild)
{
return (ENodeSructureType)1;
}
return (ENodeSructureType)(-1);
}
public static NodeStructure getParentNodeStructure(NodeStructure nodeStructure, NodeStructureList largeList)
{
for (int i = 0; i < largeList.Count; i++)
{
if (largeList[i].name == nodeStructure.parentName)
return largeList[i];
}
for (int j = 0; j < largeList.Count; j++)
{
for (int k = 0; k < largeList[j].children.Count; k++)
{
if (largeList[j].children[k].name == nodeStructure.parentName)
return largeList[j].children[k];
}
}
return null;
}
public static void getName(NodeStructure nodeStructure, ENodeSructureType nodeStructureType)
{
switch (nodeStructureType)
{
case (ENodeSructureType)0:
{ // Parent
System.IO.DirectoryInfo directoryInfo = new DirectoryInfo(nodeStructure.path);
nodeStructure.name = directoryInfo.Name;
break;
}
case (ENodeSructureType)1:
{ // Child
nodeStructure.name = Path.GetFileNameWithoutExtension(nodeStructure.path);
break;
}
case (ENodeSructureType)2:
{
// Both
DirectoryInfo directoryInfo = new DirectoryInfo(nodeStructure.path);
nodeStructure.name = directoryInfo.Name;
break;
}
}
}
public static TreeNode toTreeNode(NodeStructure nodeStructure)
{
TreeNode treeNode = new TreeNode();
treeNode.Name = nodeStructure.name;
treeNode.Text = nodeStructure.name;
treeNode.Tag = nodeStructure;
treeNode.Checked = nodeStructure.isChecked;
return treeNode;
}
public static void removePath(NodeStructure nodeStructure)
{
nodeStructure.path = null;
}
public static bool containsNodeStructure(NodeStructureList nodeStructureList, NodeStructure nodeStructure)
{
foreach (NodeStructure node in nodeStructureList)
{
if (node.name == nodeStructure.name)
{
return true;
}
}
return false;
}
public static void uncheck(NodeStructureList nodeStructureList, NodeStructure nodeStructure, ENodeStructureCheckedEntryPoint nodeStructureCheckedEntryPoint)
{
if (nodeStructure.isChild)
{
NodeStructure parent = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
NodeStructureListManager.removeNodeStructure(nodeStructure, parent.children);
nodeStructure.isChecked = false;
NodeStructureListManager.addNodeStructure(nodeStructure, parent.children);
if (nodeStructure.isParent)
{
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYPARENT)
{
for (int i = 0; i < nodeStructure.children.Count; i++)
{
uncheck(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYCHILD)
{
//Uncheck parent
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
uncheck(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER)
{
//Do both of the above.
for (int i = 0; i < nodeStructure.children.Count; i++)
{
uncheck(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
uncheck(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
}
else
{
//Just a child was selected
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER)
{
//Uncheck parent
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(nodeStructure, nodeStructureList);
uncheck(nodeStructureList, parentNodeStructure, ENodeStructureCheckedEntryPoint.FORCEDBYCHILD);
}
else if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.FORCEDBYPARENT)
{
//Do nothing...last level.
}
}
}
else if (nodeStructure.isParent)
{
nodeStructure.isChecked = false;
//Just a parent
//top level.
//FORCEDBYPARENT = IMPOSSIBLE
//FORCEDBYCHILD = DONE
if (nodeStructureCheckedEntryPoint == ENodeStructureCheckedEntryPoint.USER)
{
//Uncheck children and thus all below.
for (int i = 0; i < nodeStructure.children.Count; i++)
{
uncheck(nodeStructureList, nodeStructure.children[i], ENodeStructureCheckedEntryPoint.FORCEDBYPARENT);
}
}
}
}
