Geek asks and answers

How can I get all the extended nodes in a treeview?

I have a program containing a TreeView. All my nodes, with the exception of the root and the two nodes under the root, are loaded from the database.

When the user adds data to the database, he should automatically be added to the TreeView. I can do this by clearing all the nodes, adding the default nodes and adding all the data, including the new one, to my TreeView, but all the nodes of the new TreeView have crashed.

Our client wants to keep all the extended nodes, but still add the new data that he just added. Is there a way to find out all the extended nodes and deploy it again when it crashes or is updated? Thanks for any answer.

+5
source share
6 answers

, ( ), , . :

1)

2) ( , node, )

3) ,

( ) → node

List<string> collectExpandedNodes(TreeNodeCollection Nodes)
        {
            List<string> _lst = new List<string>();
            foreach (TreeNode checknode in Nodes)
            {
                if (checknode.IsExpanded)
                    _lst.Add(checknode.Name);
                if (checknode.Nodes.Count > 0)
                    _lst.AddRange(collectExpandedNodes(checknode.Nodes));
            }
            return _lst;
        }

, , 2 , , node , node, :

node , < node node

TreeNode FindNodeByName(TreeNodeCollection NodesCollection , string Name)
        {
          TreeNode returnNode = null; // Default value to return
          foreach (TreeNode checkNode in NodesCollection)
            {
                if (checkNode.Name == Name)  //checks if this node name is correct
                    returnNode = checkNode;
                else if (checkNode.Nodes.Count > 0 ) //node has child
                {
                    returnNode = FindNodeByName(checkNode.Nodes , Name);
                }

              if (returnNode != null) //check if founded do not continue and break
              {
                  return returnNode;
              }

            }
            //not found
            return returnNode;
        }

node

void expandNodePath(TreeNode node)
        {
            if (node == null)
                return;
            if (node.Level != 0) //check if it is not root
            {
                node.Expand();
                expandNodePath(node.Parent);
            }
            else
            {
                node.Expand(); // this is root 
            }

        }


private void button4_Click(object sender, EventArgs e)
        {
            //saving expanded nodes
            List<string> ExpandedNodes = new List<string>();
            ExpandedNodes = collectExpandedNodes(treeView1.Nodes);
            //resetting tree view nodes status to colapsed
            treeView1.CollapseAll();

            //Restore it back
            if (ExpandedNodes.Count > 0)
            {
                TreeNode IamExpandedNode;
                for (int i = 0; i < ExpandedNodes.Count;i++ )
                {
                    IamExpandedNode = FindNodeByName(treeView1.Nodes, ExpandedNodes[i]);
                    expandNodePath(IamExpandedNode);
                }

            }

        }
+5

treeView1.ExpandAll();

node

treeView1.SelectedNode.ExpandAll();

node

treeView1.Nodes[Index].Expand();
+3

,

 private void button1_Click(object sender, EventArgs e)
{
  treeView1.Nodes.Add(new TreeNode("New Node",
    new TreeNode[2] { new TreeNode("Node1"), new TreeNode("Node2") }));
  treeView1.Nodes[1].Expand();
}

,

+1

. :

//List of storage ids of expanded nodes
List<int> expandedNodeIds = new List<int>();
//call recursive fun for our tree
CollectExpandedNodes(tree.Nodes);
//recursive fun for collect expanded node ids
private void CollectExpandedNodes(TreeListNodes nodes)
{
   foreach (TreeListNode node in nodes)
   {
      if (node.Expanded) expandedNodeIds.Add(node.Id);
      if (node.HasChildren) CollectExpandedNodes(node.Nodes);
   }
}
+1

, Nodename .

private List<string> SaveTreeState(TreeNodeCollection nodes)
{
  List<string> nodeStates = new List<string>();
  foreach (TreeNode node in nodes)
  {
    if (node.IsExpanded) nodeStates.Add(node.Name);
    nodeStates.AddRange(SaveTreeState(node.Nodes));
  }
  return (nodeStates);
}


private void RestoreTreeState(TreeView tree, List<string> treeState)
{
  foreach (string NodeName in treeState)
  {
    TreeNode[] NodeList = treeView1.Nodes.Find(NodeName, true);
    if (NodeList.Length > 0) // only if node after reload is avail
      NodeList[0].Expand(); 
  }
}

:

List<string> StateList = SaveTreeState(treeView1.Nodes);
... // reload
RestoreTreeState(treeView1, StateList);
+1

, , , . , - anwser, , , .

public static IEnumerable<TreeNodeAdv> CollectExpandedNodes(this TreeNodeAdv root)
{
    Stack<TreeNodeAdv> s = new Stack<TreeNodeAdv>();
    s.Push(root);
    while (s.Count > 0)
    {
        TreeNodeAdv n = s.Pop();

        if (n.IsExpanded)
            yield return n;

        foreach (var child in n.Children.ToArray().Reverse())
        {
            s.Push(child);
        }
    }
}

, :

foreach (TreeNodeAdv expandedNode in yourTreeView.Root.CollectExpandedNodes())
{
    //Do processing on the expanded node or add in list.
}

- post-order yield IEnumerable.

+1

More articles:


All Articles