I am lost , Help Me Please ...JTree

[Kinu Kanwar]

import javax.xml.parsers.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.tree.* ;


public class XTreeTester1 extends JFrame
{

private JScrollPane jScroll;
private WindowListener winClosing;
protected DefaultMutableTreeNode rootNode;
protected DefaultTreeModel treeModel;
protected JTree tree;



public XTreeTester1( String title)
{
super( title );
setSize( 500 , 500) ;
rootNode = new DefaultMutableTreeNode("Root Node") ;
treeModel = new DefaultTreeModel(rootNode);
tree = new JTree(treeModel);


DefaultMutableTreeNode p1 = addObject(null, new DefaultMutableTreeNode("Parent 1") , false); // if null then root is father

DefaultMutableTreeNode p2 = addObject(null, new DefaultMutableTreeNode("Parent 2") , false);

addObject(p1, new DefaultMutableTreeNode("Child 1") , false); addObject(p1, new DefaultMutableTreeNode("Child 2") , false );
addObject(p2, new DefaultMutableTreeNode("Child 3") , false);
addObject(p2, new DefaultMutableTreeNode("Child 4") , false);

jScroll = new JScrollPane();
jScroll.getViewport().add( tree );
getContentPane().add( jScroll, BorderLayout.CENTER );
validate();
setVisible(true);


winClosing = new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
};
addWindowListener(winClosing);

} //END Of Constructor







public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent, DefaultMutableTreeNode child, boolean shouldBeVisible) {


treeModel.insertNodeInto(child, parent, parent.getChildCount());

return child;
}






public static void main( String[] args )
{
XTreeTester1 example2 = new XTreeTester1( "Example - 2" );
}


} //end XTreeTester


The above code works fine bu tI ahve one issue ...

When you call addObject() then you pass parent and child .... If Parent has not been already added to Tree then child does not get add ...

I am reading from text file to create JTree so its possible that child node may be there first like

xxx is child of yyy
yyy is child of zzz

zzz
yyy
xxx

would be tree structure for above text

But I cant add xxx in JTree unless yyy has been added .... Its logical but any solution for my case ??? .... When I want to add child first in tree .. Please dont ask me abt sorting of text file ....

My data is

String Id[] = "0" , "1" , "2" , "3" , "4" , "5" , "6" , "7" , "8"
String ParentId[] = "-1" , "0" , "0" , "1" , "1" , "3" ,"3" , "2" , "2"

I want to draw tree for above structure ..Any order is possible for Id array ....

Kinu

[Craig Wood]

Written in j2se 1.5 and uses autoboxing and generics. To compile in earlier versions comment/uncomment the indicated lines.

import java.awt.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.tree.*;
 
public class NodeIndexing
{
    public NodeIndexing()
    {
        int[] nodeIndices   = { 5, 2,  0, 4, 7, 8, 6, 3, 1 };
        int[] parentIndices = { 4, 6, -1, 0, 0, 5, 3, 1, 7 };
        JTree tree = getTree(nodeIndices, parentIndices);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new JScrollPane(tree));
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
 
    private JTree getTree(int[] children, int[] parents)
    {
        // find out how many parent nodes are required
        List<Integer> parentIds = new ArrayList<Integer>();    // j2se 1.5
//        List parentIds = new ArrayList();                    // j2se 1.4
        for(int j = 0; j < parents.length; j++)
        {
            int next = parents[j];
            if(!parentIds.contains(next))                       // j2se 1.5
//            if(!parentIds.contains(new Integer(next)))        // j2se 1.4
                parentIds.add(next);                            // j2se 1.5
//                parentIds.add(new Integer(next));             // j2se 1.4
        }
        int numberOfParents = parentIds.size();
        System.out.println("numberOfParents = " + numberOfParents);
 
        // set up root and parent nodes
        int rootIndexInParents = -1;
        DefaultMutableTreeNode[] nodes = new DefaultMutableTreeNode[numberOfParents];
        String created = "";
        for(int j = 0, k = 0; j < parents.length; j++)
        {
            String s = String.valueOf(parents[j]);
            if(created.indexOf(s) == -1)
            {
                if(parents[j] == -1)
                {
                    s = "root";
                    rootIndexInParents = k;
                }
                created += s + ",";
                nodes[k++] = new DefaultMutableTreeNode(s);
            }
        }
        created = created.substring(0, created.lastIndexOf(","));
        int numberCreated = created.split(",").length;
        if(numberCreated != numberOfParents)
            System.out.println("trouble in creating parent nodes");
 
        // add child nodes to parent nodes
        for(int j = 0; j < parents.length; j++)
        {
            String s = String.valueOf(children[j]);
            // does child exits in parent nodes
            DefaultMutableTreeNode child = lookupChild(s, nodes);
            // if not, make up a new child node
            if(child == null)
                child = new DefaultMutableTreeNode(s);
            DefaultMutableTreeNode parent = getParentForIndex(parents, j, nodes);
            parent.add(child);
        }
 
        DefaultMutableTreeNode root = getParentForIndex(parents,
                                                        rootIndexInParents,
                                                        nodes);
        DefaultTreeModel model = new DefaultTreeModel(root);
        return new JTree(model);
    }
 
    private DefaultMutableTreeNode getParentForIndex(int[] parents, int index,
                                               DefaultMutableTreeNode[] nodes)
    {
        String parentId = String.valueOf(parents[index]);
        if(parents[index] == -1)
            parentId = "root";
        for(int j = 0; j < nodes.length; j++)
        {
            String nodeId = (String)nodes[j].getUserObject();
            if(nodeId.equals(parentId))
                return nodes[j];
        }
        System.out.println("no match for parent id " + parentId);
        return null;
    }
 
    private DefaultMutableTreeNode lookupChild(String childId,
                                              DefaultMutableTreeNode[] parents)
    {
        for(int j = 0; j < parents.length; j++)
        {
            String parentId = (String)parents[j].getUserObject();
            if(parentId.equals(childId))
                return parents[j];
        }
        System.out.println("no match for child id " + childId);
        return null;
    }
 
    public static void main(String[] args)
    {
        new NodeIndexing();
    }
}