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