public TreeNode(string text, TreeNode[] children) { nodes = new TreeNodeCollection(this); BackColor = Color.Transparent; Enabled = true; ForeColor = DEFAULT_FORE_COLOR; ImageColor = Color.White; Text = text; if (children != null) { nodes.AddRange(children); } }
private void AddTreeNodesFor(FlatRedBall.Performance.Measurement.Section section, TreeNodeCollection treeNodeCollection) { TreeNode mostExpensive = null; float mostExpensiveValue = -1; // so it is always smaller than even the smallest starting value: double timeOfSubSections = 0; List<TreeNode> list = new List<TreeNode>(); // This may be a revisited node: foreach (TreeNode node in treeNodeCollection) { list.Add(node); } foreach (var subSection in section.Children) { TreeNode treeNode = null; treeNode = CreateTreeNode(subSection); if (subSection.Time > mostExpensiveValue) { mostExpensive = treeNode; mostExpensiveValue = subSection.Time; } timeOfSubSections += subSection.Time; list.Add(treeNode); // adding tree nodes will just add times to existing // tree nodes if they already exist AddTreeNodesFor(subSection, treeNode.Nodes); } if (mostExpensive != null) { AppendTimeInMilliseconds(mostExpensive); } if(section.Time != 0) { double ratioAccountedFor = timeOfSubSections / section.Time; if (ratioAccountedFor < .98) { TreeNode node = new TreeNode(); node.Text = "???? " + (100 - ratioAccountedFor*100).ToString("0.00") + "%"; list.Insert(0, node); } } treeNodeCollection.AddRange(list.ToArray()); }
/// <summary> /// Sort the treeview by name and child count. /// </summary> /// <param name="nodes">All child tree nodes.</param> public static void SortTreeview(TreeNodeCollection nodes) { if (nodes.Count == 0) return; List<TreeNode> leaves = new List<TreeNode>(); List<TreeNode> branches = new List<TreeNode>(); foreach (TreeNode node in nodes) { if (node.GetNodeCount(false) > 0) { branches.Add(node); SortTreeview(node.Nodes); } else { leaves.Add(node); } } nodes.Clear(); if (leaves.Count > 0) { TreeNode[] leafArray = new TreeNode[leaves.Count]; leaves.CopyTo(leafArray, 0); Comparison<TreeNode> compare = delegate(TreeNode tx, TreeNode ty) { if (tx.Text.Length != ty.Text.Length) return tx.Text.Length - ty.Text.Length; return string.Compare(tx.Text, ty.Text); }; Array.Sort<TreeNode>(leafArray, compare); nodes.AddRange(leafArray); } foreach (TreeNode node in branches) { nodes.Add(node); } }
private void FillTreeNodes( TemplateNodeInfo parent, TreeNodeCollection treeNodes ) { List<Tuple<TreeNode, ConcreteTemplateNodeDefinition>> pendingUpdateNodes = new List<Tuple<TreeNode, ConcreteTemplateNodeDefinition>>(); Action action = () => { treeNodes.Clear(); treeNodes.AddRange(parent.Childs.Select(n => { ConcreteTemplateNodeDefinition nodedef; TreeNode node = this._treeControl.CreateTreeViewNode(n, out nodedef); pendingUpdateNodes.Add(new Tuple<TreeNode, ConcreteTemplateNodeDefinition>(node, nodedef)); return node; }).ToArray()); if (parent.ChildrenAreLoadingNow) { treeNodes.Add(new TreeNode(this._treeControl._model.LocaleManager.GetLocalizedText( "common", "NodesQueryingTreeNodeText") ) { ImageKey = "NodesQuerying", SelectedImageKey = "NodesQuerying" }); } }; this._treeControl.SafeInvoke(action); foreach (Tuple<TreeNode, ConcreteTemplateNodeDefinition> pendingNode in pendingUpdateNodes) { TreeNode node = pendingNode.Item1; ConcreteTemplateNodeDefinition nodeDef = pendingNode.Item2; if (parent.IsDisabled) { nodeDef.TemplateNode.IsDisabled = true; nodeDef.NodeActivated = false; } nodeDef.NodeAvailable = nodeDef.IsAvailableForDatabase(Program.Model) ?? true; if (!nodeDef.NodeAvailable) { this._treeControl.SetNotAvailableNode(node); } else { this._treeControl.SetNodeLoaded(node); List<TemplateNodeUpdateJob> refreshJobs = nodeDef.TemplateNode.GetRefreshJob(true); nodeDef.TemplateNode.HasActiveJobs = refreshJobs.Any( job => job != null && !job.IsEmpty() && job.Enabled ); UpdateTreeCounts(node, NodeUpdatingSource.LocallyOnly); } } }
public void SortNodes(TreeNodeCollection nodes, bool recursive) { if (!isSorted) { return; } TreeNode[] nodeArray = new TreeNode[nodes.Count]; nodes.CopyTo(nodeArray, 0); Array.Sort(nodeArray, nodeSorter); nodes.Clear(); nodes.AddRange(nodeArray); if (recursive) { foreach (TreeNode childNode in nodeArray) { SortNodes(childNode.Nodes, true); } } }
static void CreateNodeList(TreeNodeCollection nodes, object target) { var treeNodes = CreateNodes(target); //Tracer.FlaggedLine(treeNodes.Dump()); //Tracer.ConditionalBreak(treeNodes.Length == 20,""); nodes.Clear(); nodes.AddRange(treeNodes); }
public void AddObjectsToTreeNodeCollection(TreeNodeCollection col, List<OutlinerNode> nodes, Boolean addChildNodes) { if (nodes == null || nodes.Count == 0) return; List<TreeNode> newNodes = new List<TreeNode>(); foreach (OutlinerNode node in nodes) { if (!_treeNodes.ContainsKey(node) && Filter.ShowNode(node) && (!(ListMode == OutlinerListMode.Layer) || !HideGroupMembersLayerMode || !(node is OutlinerObject) || !((OutlinerObject)node).IsGroupMember)) { TreeNode tn = CreateTreeNodeForOutlinerNode(node); // Add node to outlinernode/treenode dictionary. _treeNodes.Add(node, tn); newNodes.Add(tn); // Recursively go through childnodes. if ((addChildNodes && node.ChildNodesCount > 0) || !(node is OutlinerObject)) AddObjectsToTreeNodeCollection(tn.Nodes, node.ChildNodes, addChildNodes); } } col.AddRange(newNodes.ToArray()); }
public void SortNodes(TreeNodeCollection nodes, bool recursive) { if (this.isSorted) { TreeNode[] dest = new TreeNode[nodes.Count]; nodes.CopyTo(dest, 0); Array.Sort<TreeNode>(dest, this.nodeSorter); nodes.Clear(); nodes.AddRange(dest); if (recursive) { foreach (TreeNode node in dest) { this.SortNodes(node.Nodes, true); } } } }
/// <summary>Sorts the specified nodes.</summary> /// <param name="nodes">The nodes.</param> /// <param name="recursive">if set to <c>true</c> recursively sorts the children nodes.</param> protected void SortNodes(TreeNodeCollection nodes, bool recursive) { TreeNode[] array = new TreeNode[nodes.Count]; nodes.CopyTo(array, 0); Array.Sort(array, base.TreeViewNodeSorter); nodes.Clear(); nodes.AddRange(array); if (recursive) { foreach (TreeNode child in array) SortNodes(child.Nodes, true); } }
/// <summary>Refreshes the specified nodes.</summary> /// <param name="nodes">The nodes.</param> private void RefreshNodes(TreeNodeCollection nodes) { TreeNode[] dest = new TreeNode[nodes.Count]; nodes.CopyTo(dest, 0); nodes.Clear(); nodes.AddRange(dest); }