C#

Eddy Vluggen wrote:

polling is bad.

/// <summary>
/// Adds a branch to a TreeView control
/// </summary>
/// <remarks>
/// The Path contains the name of the node to be used in the tree view, for example
/// "General" or "Colours".
/// If the path is qualified with '\' or '/' then it is treated as a hierarchical path
/// and the full path required is generated. For example, if the path was
/// "General\Colors\Pens" the the tree view would display
///      General
///          Colours
///              Pens
/// and any of these branches would select the node.
///
/// The Description can be used for the display of more information.
/// </remarks>
/// <example>
/// AddBranch(tvSelect.Nodes,
///           @"General\Colours",
///           @"Change the colours settings for items",
///           object o);
/// </example>
/// <param name="nc">TreeNodeCollection: TreeView Nodes collection to add to</param>
/// <param name="Path">string: TreeView Hierarchy path to object</param>
/// <param name="Description">string: Plain english description of the object</param>
/// <param name="o">object: object to add to TreeView</param>
public static void AddBranch(TreeNodeCollection nc, string Path, string Description, object o)
    {
    string[] paths = Path.Split('\\', '/'); // Break "General\Font" to "General", "Font" etc.
    TreeNode node;
    foreach (string s in paths)
        {
        if (s == null || s == "")
            {
            // Ignore leading "\", or instances of "\\".
            continue;
            }
        if ((node = FindBranch(nc, s)) == null)
            {
            // Branch does not exist.
            // create it.
            node = new TreeNode();
            node.Name = Description;
            node.Text = s;
            node.Tag = o;
            nc.Add(node);
            }
        // Move down the tree.
        // This allows us to create the sub-branches.
        nc = node.Nodes;
        }
    }

/// <summary>
/// Locates a given Node, returns it if found
/// </summary>
/// <param name="nc">TreeNodeCollection: List of TreeNode items to search</param>
/// <param name="name">string: Name of branch (or leaf) to search for.</param>
/// <returns>Node if found, null if not.</returns>
public static TreeNode FindBranch(TreeNodeCollection nc, string name)
    {
    if ((name != null) && (name != ""))
        {
        foreach (TreeNode n in nc)
            {
            if (n.Text == name)
                {
                return n;
                }
            }
        }
    return null;
    }

private DataTable GenDT(string strSelect)
{
    if (con.State != ConnectionState.Open)
        con.Open();


    DataTable _dt = new DataTable();
    try
    {
        new OracleDataAdapter(strSelect, con).Fill(_dt);
    }
    catch (Exception) { }
    return _dt;
}

private void LoadBudgetLineItems()
{
    DataTable dt = GenDT(@"SELECT CODE, NAME, PARENT FROM BUDGETLINES ORDER BY CODE");
    int L1,L2;
    L1 = L2 = -1;

    TreeGridNode node = new TreeGridNode();
    foreach (DataRow dr in dt.Rows)
    {
        if (dr["PARENT"].ToString().Length == 0)
        {
            //Parent
            node = treeGridView1.Nodes.Add(null, dr["CODE"], dr["NAME"], "");
            node.ImageIndex = 0;
            node.DefaultCellStyle.Font = boldFont;
            node.DefaultCellStyle.BackColor = Color.Black;
            node.DefaultCellStyle.ForeColor = Color.White;
            L1++;

            //Level 2
            foreach (DataRow dr2 in dt.Rows)
            {
                if (dr2["PARENT"].ToString().Equals(dr["CODE"].ToString()))
                {
                    node = treeGridView1.Nodes[L1].Nodes.Add(null, dr2["CODE"], dr2["NAME"], "");
                    node.ImageIndex = 1;

                }
            }
        }

    }
}

public sealed class Node
{
    readonly List<Node> childNodes = new List<Node>();
    Node parent = null;
    public Node(int id, string name)
    {
        this.Id = id;
        this.Name = name;
    }

    public void AddChild(Node node)
    {
        node.SetParent(this);
        childNodes.Add(node);
    }

    public void SetParent(Node parent)
    {
        this.parent = parent;
    }

    public Node FindNode(int id)
    {
        Node result = childNodes.SingleOrDefault(node => node.Id == id);
        if (result == null)
        {
            foreach (Node node in childNodes)
                result = node.FindNode(id);
        }
        return result;
    }

    public void PrintTree(Action<Node> callback)
    {
        callback(this);
        foreach (Node node in childNodes)
            node.PrintTree(callback);
    }

    public override string ToString()
    {
        return string.Format("Id : {0}, Parent Name : {1}, Name : {2}", 
            Id, parent == null ? "No parent" : parent.Name, Name);
    }

    public int Id { get; private set; }

    public string Name { get; private set; }
}

Node baseLine = new Node(0, "BaseLine");
baseLine.AddChild(new Node(1, "A"));

// find A node to add A1 and A2 as its children
Node aNode = baseLine.FindNode(1);
aNode.AddChild(new Node(2, "A1"));
aNode.AddChild(new Node(3, "A2"));

baseLine.AddChild(new Node(4, "B"));

// find B node to add B1 and B2 as its children
Node bNode = baseLine.FindNode(4);
bNode.AddChild(new Node(5, "B1"));
bNode.AddChild(new Node(6, "B2"));

// printing the whole tree
baseLine.PrintTree(node => Console.WriteLine(node));
Console.ReadKey();

ID    Parent    Name
------------------------
0     0         BaseLine
1     0         A
2     1         A1
3     1         A2
4     0         B
5     4         B1
6     4         B2

bool firstIteration = true;
Node baseLine = null;
foreach (DataRow row in dt.Rows)
{
    if (firstIteration)
    {
        baseLine = new Node(int.Parse(row["Id"].ToString()),
            row["Name"].ToString());
        firstIteration = false;
    }
    else
    {
        int parentId = int.Parse(row["Parent"].ToString());
        Node parent = (baseLine.Id == parentId) ? baseLine :  baseLine.FindNode(parentId);
        parent.AddChild(new Node(int.Parse(row["Id"].ToString()),
                row["Name"].ToString()));
    }
}
baseLine.PrintTree(node => Console.WriteLine(node));
Console.ReadKey();

Muammar© wrote:

but I still dont get what your PrintTree is for

Muammar© wrote:

I just want to fill a treeView control on a windows form

public sealed class TreeNodeBuilder
{
    Node root = null;
    Dictionary<int, TreeNode> treeNodes = new Dictionary<int, TreeNode>();
    public TreeNodeBuilder(Node root)
    {
        this.root = root;
    }

    public TreeNode BuildTreeNode()
    {
        // root node. Baseline in your case
        TreeNode rootTreeNode = null;
        root.PrintTree(delegate(Node node)
        {
            // parent is null, this will be the root
            if (node.Parent == null)
            {
                rootTreeNode = new TreeNode(node.Name);
                rootTreeNode.Tag = node;
                // keeping this treenode
                treeNodes.Add(node.Id, rootTreeNode);
            }
            else
            {
                // checking any tree node added for this parent id
                if (treeNodes.ContainsKey(node.Parent.Id))
                {
                    TreeNode parent = treeNodes[node.Parent.Id];
                    TreeNode current = parent.Nodes.Add(node.Name);
                    current.Tag = node;
                    treeNodes.Add(node.Id, current);
                }
            }
        });
        return rootTreeNode;
    }
}

// Code to create node in a loop. Same in the last post
TreeNodeBuilder nodeBuilder = new TreeNodeBuilder(baseLine); // baseline will be root node
treeView1.Nodes.Add(nodeBuilder.BuildTreeNode());