public static NodeStructureList reindex(NodeStructureList nodeStructureList)
{
for (int i = 0; i < nodeStructureList.Count; i++)
{
nodeStructureList[i].index = i;
}
return nodeStructureList;
}
public NodeStructure()
{
parentName = String.Empty;
children = new NodeStructureList();
isChecked = false;
level = 0;
index = 0;
name = null;
path = null;
isExpanded = true;
}
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 mergeNodeStructureLists(NodeStructureList highList, NodeStructureList lowList)
{
NodeStructure theNode = null;
int numberParents = highList.Count;
for (int i = 0; i < lowList.Count; i++)
{
if (i < numberParents)
{
//Checking top level nodes for matches
if (NodeStructureListManager.containsNodeStructure(highList, lowList[i]))
{
theNode = NodeStructureListManager.getNodeStructureWithName(highList, lowList[i].name);
NodeStructureListManager.removeNodeStructure(theNode, highList);
theNode.isExpanded = lowList[i].isExpanded;
theNode.isChecked = lowList[i].isChecked;
NodeStructureListManager.addNodeStructure(theNode, highList);
}
int numberChildren = highList[i].children.Count;
for (int a = 0; a < lowList[i].children.Count; a++)
{
if (a < numberChildren)
{
//Checking mid level nodes for matches
if (NodeStructureListManager.containsNodeStructure(highList[i].children, lowList[i].children[a]))
{
theNode = NodeStructureListManager.getNodeStructureWithName(highList[i].children, lowList[i].children[a].name);
NodeStructureListManager.removeNodeStructure(theNode, highList[i].children);
theNode.isExpanded = lowList[i].children[a].isExpanded;
theNode.isChecked = lowList[i].children[a].isChecked;
NodeStructureListManager.addNodeStructure(theNode, highList[i].children);
}
int numberFiles = highList[i].children[a].children.Count;
for (int b = 0; b < lowList[i].children[a].children.Count; b++)
{
if (b < numberFiles)
{
//Checking bottom level nodes for matches
if (NodeStructureListManager.containsNodeStructure(highList[i].children[a].children, lowList[i].children[a].children[b]))
{
theNode = NodeStructureListManager.getNodeStructureWithName(highList[i].children[a].children, lowList[i].children[a].children[b].name);
NodeStructureListManager.removeNodeStructure(theNode, highList[i].children[a].children);
theNode.isExpanded = lowList[i].children[a].children[b].isExpanded;
theNode.isChecked = lowList[i].children[a].children[b].isChecked;
NodeStructureListManager.addNodeStructure(theNode, highList[i].children[a].children);
}
}
}
}
}
}
}
return highList;
}
public static NodeStructure getNodeStructureWithName(NodeStructureList nodeStructureList, string name)
{
for (int i = 0; i < nodeStructureList.Count; i++)
{
if (nodeStructureList[i].name == name)
{
return nodeStructureList[i];
}
}
return null;
}
public static NodeStructureList removeDuplicateNodes(NodeStructureList nodeStructureList)
{
NodeStructure nodeStructure = null;
for (int j = 0; j < nodeStructureList.Count; j++)
{
nodeStructure = nodeStructureList[j];
int index = j + 1;
if (j != nodeStructureList.Count - 1)
{
for (int i = index; i < nodeStructureList.Count; i++)
{
if (nodeStructureList[i].name == nodeStructure.name)
{
NodeStructureListManager.removeNodeStructure(nodeStructureList[i], nodeStructureList);
i--;
}
}
}
}
return nodeStructureList;
}
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 uncheckAllNodeStructures(NodeStructureList nodeStructureList)
{
NodeStructure nodeStructure = null;
for (int i = 0; i < nodeStructureList.Count; i++)
{
nodeStructure = nodeStructureList[i];
NodeStructureManager.uncheck(nodeStructureList, nodeStructure, ENodeStructureCheckedEntryPoint.USER);
}
}
public static void saveExpandedState(NodeStructureList nodeStructureList, TreeView treeView)
{
//Precondition: nodeStructureList.Count (and all child counts) = treeView.Nodes.Count (and all child counts)
for (int i = 0; i < treeView.Nodes.Count; i++)
{
nodeStructureList[i].isExpanded = treeView.Nodes[i].IsExpanded;
for (int j = 0; j < treeView.Nodes[i].Nodes.Count; j++)
{
nodeStructureList[i].children[j].isExpanded = treeView.Nodes[i].Nodes[j].IsExpanded;
for (int k = 0; k < treeView.Nodes[i].Nodes[j].Nodes.Count; k++)
{
nodeStructureList[i].children[j].children[k].isExpanded = treeView.Nodes[i].Nodes[j].Nodes[k].IsExpanded;
}
}
}
}
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 void expandProperNodes(NodeStructureList nodeStructureList, TreeView treeView)
{
//Precondition: nodeStructureList.Count (and all child counts) = treeView.Nodes.Count (and all child counts)
for (int i = 0; i < nodeStructureList.Count; i++)
{
if (nodeStructureList[i].isExpanded)
treeView.Nodes[i].Expand();
else
treeView.Nodes[i].Collapse(true);
for (int j = 0; j < nodeStructureList[i].children.Count; j++)
{
if (nodeStructureList[i].children[j].isExpanded)
treeView.Nodes[i].Nodes[j].Expand();
else
treeView.Nodes[i].Nodes[j].Collapse(true);
for (int k = 0; k < nodeStructureList[i].children[j].children.Count; k++)
{
if (nodeStructureList[i].children[j].children[k].isExpanded)
treeView.Nodes[i].Nodes[j].Nodes[k].Expand();
else
treeView.Nodes[i].Nodes[j].Nodes[k].Collapse(true);
}
}
}
}
public static void fillTreeView(NodeStructureList nodeStructureList, TreeView treeView, TreeNode treeNode, int occurance)
{
treeView.Nodes.Clear();
treeView.BeginUpdate();
int i = 0, j = 0;
foreach (NodeStructure nodeStructure in nodeStructureList)
{
treeView.Nodes.Add(NodeStructureManager.toTreeNode(nodeStructure));
if (nodeStructure.isExpanded)
treeView.Nodes[i].Expand();
else
treeView.Nodes[i].Collapse(false);
if (nodeStructure.isParent)
{
foreach (NodeStructure childNodeStructure in nodeStructure.children)
{
treeView.Nodes[i].Nodes.Add(NodeStructureManager.toTreeNode(childNodeStructure));
if (childNodeStructure.isExpanded)
treeView.Nodes[i].Nodes[j].Expand();
else
treeView.Nodes[i].Nodes[j].Collapse(false);
if (childNodeStructure.isParent)
{
foreach (NodeStructure requestNodeStructure in childNodeStructure.children)
{
treeView.Nodes[i].Nodes[j].Nodes.Add(NodeStructureManager.toTreeNode(requestNodeStructure));
}
}
j++;
}
}
i++;
j = 0;
}
expandProperNodes(nodeStructureList, treeView);
if (occurance == 1)
{
NodeStructure childNodeStructure = (NodeStructure)(treeNode).Tag;
if (childNodeStructure.isChild)
{
if (childNodeStructure.isParent)
{
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(childNodeStructure, nodeStructureList);
treeView.TopNode = treeView.Nodes[parentNodeStructure.index].Nodes[childNodeStructure.index];
}
else
{
NodeStructure parentNodeStructure = NodeStructureManager.getParentNodeStructure(childNodeStructure, nodeStructureList);
NodeStructure theParent = NodeStructureManager.getParentNodeStructure(parentNodeStructure, nodeStructureList);
treeView.TopNode = treeView.Nodes[theParent.index].Nodes[parentNodeStructure.index].Nodes[childNodeStructure.index];
}
}
else
treeView.TopNode = treeView.Nodes[treeNode.Index];
}
else
{
treeView.TopNode = treeView.Nodes[0];
}
treeView.EndUpdate();
}
public static void updateRequests(NodeStructureList nodeStructureList, TreeView treeView, ENodeStructureCheckedEntryPoint nodeStructureCheckedEntryPoint, TreeNode treeNode, int occurance)
{
if (occurance == 1)
saveExpandedState(nodeStructureList, treeView);
NodeStructure nodeStructure = null, childNodeStructure = null, endNodeStructure = null;
for (int i = 0; i < treeView.Nodes.Count; i++)
{
nodeStructure = (NodeStructure)(treeView.Nodes[i].Tag);
if (differencesExist(nodeStructure, treeView.Nodes[i]) == (EDifferenceToMake)(0) || differencesExist(nodeStructure, treeView.Nodes[i]) == (EDifferenceToMake)(1))
synchronize(differencesExist(nodeStructure, treeView.Nodes[i]), nodeStructure, nodeStructureList, treeView, nodeStructureCheckedEntryPoint, treeNode, occurance);
if (nodeStructure.isParent)
{
for (int j = 0; j < treeView.Nodes[i].Nodes.Count; j++)
{
childNodeStructure = (NodeStructure)(treeView.Nodes[i].Nodes[j].Tag);
if (differencesExist(childNodeStructure, treeView.Nodes[i].Nodes[j]) == (EDifferenceToMake)(0) || differencesExist(childNodeStructure, treeView.Nodes[i].Nodes[j]) == (EDifferenceToMake)(1))
synchronize(differencesExist(childNodeStructure, treeView.Nodes[i].Nodes[j]), childNodeStructure, nodeStructureList, treeView, nodeStructureCheckedEntryPoint, treeNode, occurance);
if (childNodeStructure.isParent)
{
for (int k = 0; k < treeView.Nodes[i].Nodes[j].Nodes.Count; k++)
{
endNodeStructure = (NodeStructure)(treeView.Nodes[i].Nodes[j].Nodes[k].Tag);
if (differencesExist(endNodeStructure, treeView.Nodes[i].Nodes[j].Nodes[k]) == (EDifferenceToMake)(0) || differencesExist(endNodeStructure, treeView.Nodes[i].Nodes[j].Nodes[k]) == (EDifferenceToMake)(1))
synchronize(differencesExist(endNodeStructure, treeView.Nodes[i].Nodes[j].Nodes[k]), endNodeStructure, nodeStructureList, treeView, nodeStructureCheckedEntryPoint, treeNode, occurance);
}
}
}
}
}
}
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 NodeStructureList alphabetize(NodeStructureList nodeStructureList)
{
nodeStructureList.Sort((s1, s2) => s1.name.CompareTo(s2.name));
return 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 NodeStructureList getCheckedNodes(NodeStructureList nodeStructureList)
{
NodeStructureList nodeList = new NodeStructureList();
foreach (NodeStructure nodeStructure in nodeStructureList)
{
if (nodeStructure.isParent)
{
foreach (NodeStructure childNodeStructure in nodeStructure.children)
{
if (childNodeStructure.isParent)
{
foreach (NodeStructure endNodeStructure in childNodeStructure.children)
{
if (endNodeStructure.isChecked)
{
NodeStructureListManager.addNodeStructure(endNodeStructure, nodeList);
}
}
}
}
}
}
return nodeList;
}
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);
}
}
}
}
