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); } } } }