Exemple #1
0
        private TreeNode createTreeNode(DBNode <T> node)
        {
            TreeNode treeNode;

            if (treeNodeLookup.ContainsKey(node))
            {
                return(treeNodeLookup[node]);
            }
            else
            {
                treeNode             = new TreeNode();
                treeNode.Tag         = node;
                treeNodeLookup[node] = treeNode;
            }

            node.UpdateDynamicNode();
            node.Children.Sort();

            setVisualProperties(treeNode);
            updateFilteredItems(treeNode, false);

            // add any missing children
            foreach (DBNode <T> currSubNode in node.Children)
            {
                TreeNode child = createTreeNode(currSubNode);
                if (!treeNode.Nodes.Contains(child))
                {
                    treeNode.Nodes.Add(child);
                }
            }

            treeNode.Collapse();
            node.Modified += new DBNodeEventHandler(nodeModified);
            watchedNodes.Add(node);

            return(treeNode);
        }
Exemple #2
0
        private void updateFilteredItems(TreeNode treeNode, bool forcePopulation)
        {
            DBNode <T> node = treeNode.Tag as DBNode <T>;

            // make sure we have an updatable node and we are not already processing
            if (node == null)
            {
                return;
            }
            if (updatingNodes.Contains(node))
            {
                return;
            }
            updatingNodes.Add(node);

            // if this is a dynamic node, update the children at model level
            if (node.DynamicNode)
            {
                node.UpdateDynamicNode();
            }

            // if the node is not expanded and is a leaf node, don't worry about populating it for now
            if (!forcePopulation && !treeNode.IsExpanded && node.Children.Count == 0 && node.Filter != null)
            {
                if (treeNode.Nodes.Count == 0)
                {
                    treeNode.Nodes.Add(new TreeNode("dummy"));
                }

                updatingNodes.Remove(node);
                return;
            }

            treeNode.Nodes.Clear();

            // if this node has children, add, update those children, then exit
            if (node.Children.Count > 0)
            {
                foreach (DBNode <T> currSubNode in node.Children)
                {
                    if (treeNodeLookup.ContainsKey(currSubNode))
                    {
                        treeNode.Nodes.Add(treeNodeLookup[currSubNode]);
                        updateFilteredItems(treeNodeLookup[currSubNode], false);
                    }
                }

                updatingNodes.Remove(node);
                return;
            }

            // if this is a dynamic node, add any missing children
            if (node.DynamicNode)
            {
                foreach (DBNode <T> currSubNode in node.Children)
                {
                    TreeNode child = createTreeNode(currSubNode);
                    if (!treeNode.Nodes.Contains(child))
                    {
                        treeNode.Nodes.Add(child);
                    }
                }

                updatingNodes.Remove(node);
                return;
            }

            // add all leaf nodes
            node.DBManager = DBManager;
            if (node.Children.Count == 0)
            {
                foreach (T currItem in node.GetFilteredItems().OrderBy((item) => item.ToString()))
                {
                    TreeNode itemNode = new TreeNode(currItem.ToString());
                    itemNode.Tag = currItem;
                    treeNode.Nodes.Add(itemNode);
                    setVisualProperties(itemNode);
                }

                updatingNodes.Remove(node);
                return;
            }

            updatingNodes.Remove(node);
        }