public BuildDefinitionExplorerNode(IBuildDefinitionTreeNode node, char separator, ITFS tfs) : base(node.Path, node.Name) { TFS = tfs; Node = node; if (_hiconLeaf == IntPtr.Zero && _hiconOpenFolder == IntPtr.Zero) { _hiconLeafAllBuildDef = ((Bitmap)BuildExplorerPlugin.Icons.Images[0]).GetHicon(); _hiconLeaf = ((Bitmap)BuildExplorerPlugin.Icons.Images[2]).GetHicon(); _hiconOpenFolder = ((Bitmap)BuildExplorerPlugin.Icons.Images[4]).GetHicon(); _hiconCloseFolder = ((Bitmap)BuildExplorerPlugin.Icons.Images[3]).GetHicon(); } this.separator = separator; if (node.Children.Count == 0 /*&& node.Name!="All Build Definitions"*/) { InitAsLeaf(); } else { InitAsFolder(); } IsAllBuildDefinitionsNode = node.Name == "All Build Definitions"; if (IsAllBuildDefinitionsNode) { NodePriority = AllBuildDefinitionsNodePriority; } IsDisabled = node.IsDisabled; }
public static List <IBuildDefinitionTreeNode> ValidateAsRoot(this IBuildDefinitionTreeNode src, string name) { _currentRoot = src; _nodesCheked.Clear(); Assert.IsTrue(src.IsRoot, "node is not root"); Assert.AreEqual(src.Name, name, "Name mismatch"); _nodesCheked.Add(src); return(new List <IBuildDefinitionTreeNode>(src.Children)); }
private void RecursiveBuildNodes(IBuildDefinitionTreeNode root, BaseHierarchyNode teNode, char sep) { //create nodes on this level and call recursive on children. foreach (var buildNode in root.Children.Select(node => new BuildDefinitionExplorerNode(node, sep, TFS))) { buildNode.AddChildren(); teNode.AddChild(buildNode); } teNode.Expand(false); }
public static IBuildDefinitionTreeNode VerifyAllChecked(this IBuildDefinitionTreeNode src) { Check(_currentRoot); VerifyAllChecked(_currentRoot.Children); Assert.IsTrue(_nodesCheked.Count == 0, "No check on the following nodes:" + Environment.NewLine + _nodesCheked.Aggregate("", (outString, nextNode) => outString + Environment.NewLine + PrintNode(nextNode))); return(_currentRoot); }
internal void AddChild(IBuildDefinitionTreeNode child) { ((BuildDefinitionTreeNode)child).Parent = this; _children.Add(child); }
/// <summary> /// Populate a IBuildDefinitionTreeNode with a new path. /// </summary> /// <param name="path">The path to to the build definition.</param> /// <param name="sep">The seperator</param> /// <param name="root">The root if not provided it will be created.</param> /// <param name="disabled">True if the build is marked as disabled</param> /// <returns>The root</returns> public static IBuildDefinitionTreeNode CreateOrMergeIntoTree(string path, char sep, IBuildDefinitionTreeNode root, bool disabled) { Contract.Requires(root != null); IBuildDefinitionTreeNode returnRoot = null; //path contains the parent.Name. var parent = root; //split to get parent, child and the rest if possible we want null results (StringSplitOptions.None) since that makes testing simpler. var parts = _splitStrategy.GenerateFoldersFromName(path, sep); //special case when only adding root. if (parts.Length == 1) { return(new BuildDefinitionRootNode(parts.Last(), sep)); } //generate needed hierarchy. //ignore last part: is it allways treated as leaf. for (var i = 0; i < parts.Length - 1; i++) { var part = parts[i]; //if root does not exists, use first part to generate root name. if (returnRoot == null) { parent = root ?? new BuildDefinitionRootNode(part, sep); //root returnRoot = parent; } else { //Find the existing child with the name if any. var part1 = part; //first node with same name and which is not a leaf node //this will support //Builds: // test.min // test var folder = parent.Children.Where(c => Compare(part1, c.Name) && !c.IsLeafNode).FirstOrDefault(); if (folder == null) { folder = new BuildDefinitionFolderNode(part, sep); ((BuildDefinitionTreeNode)parent).AddChild(folder); } parent = folder; } } //allways add last part as leaf node if not only root if (parts.Length > 1) { // Check to see if the last part is an existing folder var part1 = parts.Last(); var folder = parent.Children.Where(c => Compare(part1, c.Name)).FirstOrDefault(); if (folder != null) // // Check to see if the last part is an existing folder { parent = folder; part1 = "$"; } var leaf = new BuildDefinitionLeafNode(part1, sep, disabled); ((BuildDefinitionTreeNode)parent).AddChild(leaf); } return(returnRoot); }
public static IBuildDefinitionTreeNode CreateOrMergeIntoTree(string path, char sep, IBuildDefinitionTreeNode root) { return(CreateOrMergeIntoTree(path, sep, root, false)); }
private static string PrintNode(IBuildDefinitionTreeNode node) { return("Unchecked node " + node.Name + ", isLeaf = " + node.IsLeafNode + ", IsDisabled " + node.IsDisabled + ", Path = " + node.Path); }
private static void Check(IBuildDefinitionTreeNode node) { Assert.IsTrue(_nodesCheked.Contains(node), PrintNode(node)); _nodesCheked.Remove(node); }
public BuildDefinitionExplorerNode(IBuildDefinitionTreeNode node, char separator, bool isFolderNode, ITFS tfs) : this(node, separator, tfs) { this.isFolderNode = isFolderNode; }