JTreeDemo.java

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
import java.util.*;

public class JTreeDemo extends javax.swing.JFrame
{
   JPanel Display_Panel = new JPanel();
   JTextField jtf_Tree_Path = new JTextField(25);
   JButton jbtn_Add_One = new JButton("Add One");
   JButton jbtn_Add_Many = new JButton("Add Many");
   JButton jbtn_Change_Renderer1 = new JButton("Change Renderer 1");
   JButton jbtn_Change_Renderer2 = new JButton("Change Renderer 2");
    
   JTree jt = null;
   DefaultTreeModel Example_TreeModel = null;
    
	public JTreeDemo(String s_Title)
	{
	   // Setup a basic frame to run everything in
		setTitle(s_Title);
		setDefaultCloseOperation(javax.swing.JFrame.DO_NOTHING_ON_CLOSE);
		getContentPane().setLayout(new BorderLayout(0,0));
		setSize(450,500);
		setVisible(false);

      // Add a window listern so that everyting can be shutdown/exited normally
      addWindowListener( new WindowAdapter() {
         public void windowClosing( WindowEvent e) 
            {
                        System.exit(0);
            }
      });

// ** 1 **
      // Create a new JTree using the Default Table Model which is
      // created using DefaultMutableTreeNode returned by the Build_Tree 
      //method (see below)
      Example_TreeModel = new DefaultTreeModel( Build_Tree() );
		jt = new JTree( Example_TreeModel );
		
		// Set the Line style the default is not very interesting
		// "Angled" "None" "Horizontal"
		jt.putClientProperty("JTree.lineStyle", "Angled");
		
		// Add a listener to the tree to handle TreeSelectionEvents
      jt.addTreeSelectionListener(tsl);
		
		// Put the Tree is a scrollpane so that is can be expanded and contracted even if it extends beyond the 
		// borders of the viewable area
		JScrollPane jsp = new JScrollPane(jt);
		jsp.setPreferredSize(new Dimension(200,350) );

		// Put the JTree up top
		getContentPane().add(BorderLayout.NORTH, jsp);

      // Put the display panel on the bottom with a JTextfield for displaying the tree path
      Display_Panel.setLayout(new GridLayout(0,1));

      Display_Panel.add(jtf_Tree_Path);
      Display_Panel.add(jbtn_Add_One);
      Display_Panel.add(jbtn_Add_Many);
      Display_Panel.add(jbtn_Change_Renderer1);
      Display_Panel.add(jbtn_Change_Renderer2);
        
		getContentPane().add(BorderLayout.SOUTH, Display_Panel);
    
      jtf_Tree_Path.setText("Selecte a node to see the 'Tree Path'.");
        
      My_Action_Listener al = new My_Action_Listener();
      jbtn_Add_One.addActionListener(al);
      jbtn_Add_Many.addActionListener(al);
      jbtn_Change_Renderer1.addActionListener(al);
      jbtn_Change_Renderer2.addActionListener(al);
	}

   class My_Action_Listener implements ActionListener
   {
      public void actionPerformed( ActionEvent e)
      {
         Object o = e.getSource();
         if ( o == jbtn_Add_One)
            Add_One();
         else if (o == jbtn_Add_Many)
            Add_Many();
         else if (o == jbtn_Change_Renderer1)
            Change_Renderer1();
         else if (o == jbtn_Change_Renderer2)
            Change_Renderer2();
      }
   }

	static public void main(String args[])
	{
		try {
		    
	      // Uncomment out the next block of code to use the default systems Look and Feel
		   /* 
		   try {
		      UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		   } 
		   catch (Exception e) { 
		   }
         */
            
			//Create a new instance of our application's frame, and make it visible.
			(new JTreeDemo("JTree Demo")).setVisible(true);
		} 
		catch (Throwable t) {
			t.printStackTrace();
			//Ensure the application exits with an error condition.
			System.exit(1);
		}
	}

// ** 2 **
   DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
    
   DefaultMutableTreeNode Build_Tree()
   {
      // Create the root node (Mutable indicates that the nodes can be 
      //          changed and add to or deleted from)
        
      DefaultMutableTreeNode A    = new DefaultMutableTreeNode("A");
      DefaultMutableTreeNode B    = new DefaultMutableTreeNode("B");
      DefaultMutableTreeNode C    = new DefaultMutableTreeNode("C");
      DefaultMutableTreeNode D    = new DefaultMutableTreeNode("D");
        
      DefaultMutableTreeNode A_1 = new DefaultMutableTreeNode("1");
      DefaultMutableTreeNode A_2 = new DefaultMutableTreeNode("2");
      DefaultMutableTreeNode A_3 = new DefaultMutableTreeNode("3");
        
      A.add(A_1);
      A.add(A_2);
      A.add(A_3);
        
      DefaultMutableTreeNode B_1 = new DefaultMutableTreeNode("1");
      DefaultMutableTreeNode B_2 = new DefaultMutableTreeNode("2");
        
      B.add(B_1);
      B.add(B_2);
        
      // Create the nodes using an Object other than a String
        
      C.add(new DefaultMutableTreeNode(  new My_Node("My Node Instance") ) );   
        
      // Create the nodes using a Vector
      Vector v = new Vector();
      for (int i = 1 ; i <= 10 ; i++)
      {
         v.addElement("D"+ String.valueOf(i));
      }
      JTree.DynamicUtilTreeNode.createChildren(D, v);
        
      root.add(A);
      root.add(B);
      root.add(C);
      root.add(D);
        
      return root;
   }

// ** 3 **  Note This Code does not work correctly
   int i_Count_Down = -1;
    
   void Add_One()
   {
      System.out.println("Add One");
      DefaultMutableTreeNode Node = 
         new DefaultMutableTreeNode(String.valueOf(i_Count_Down--));
        
      int index = Example_TreeModel.getIndexOfChild(root, null);
      System.out.println(index);
      //index = 1;
      System.out.println(root);
      System.out.println(Node);
      Example_TreeModel.insertNodeInto(Node,root, index);
   }

// ** 4 **

   int i_Count_Up = 0;

   void Add_Many()
   {
      System.out.println("Add Many");

      for ( int i = 0 ; i < 5 ; i++ ) 
      {
         DefaultMutableTreeNode Node = 
            new DefaultMutableTreeNode(String.valueOf(i_Count_Up++));
                    
         root.add(Node);
      }
      this.Example_TreeModel.nodeStructureChanged(root);
   }


// ** 5 **
   void Change_Renderer1()
   {
      System.out.println("Change Renderer 1");
        
      DefaultTreeCellRenderer renderer = 
         (DefaultTreeCellRenderer) jt.getCellRenderer();
                            
      renderer.setTextNonSelectionColor(Color.blue);
      renderer.setTextSelectionColor(Color.red);
        
      this.Example_TreeModel.nodeStructureChanged(root);
   }

// ** 6 **

   void Change_Renderer2()
   {
      System.out.println("Change Renderer 2");

      My_Tree_Cell_Renderer r = new My_Tree_Cell_Renderer( (DefaultTreeCellRenderer) jt.getCellRenderer() );
      jt.setCellRenderer(r);
      this.Example_TreeModel.nodeStructureChanged(root);
   }

// ** 7 **

   class My_Tree_Cell_Renderer extends DefaultTreeCellRenderer
   {
      DefaultTreeCellRenderer orig_tcr = null;
       
      public My_Tree_Cell_Renderer(DefaultTreeCellRenderer orig)
      {
         orig_tcr = orig;
      }
        
      public Component getTreeCellRendererComponent(JTree tree, Object value,
                              boolean sel,   boolean expanded, boolean leaf,
                              int row, boolean hasFocus)
      {
         Component c = orig_tcr.getTreeCellRendererComponent(tree, value,sel,
                                    expanded, leaf, row,hasFocus);
         //System.out.println(value.toString());
         
         if ( value.toString().startsWith("D") )
            c.setBackground(Color.yellow);
         else 
            c.setBackground(Color.black);
          
         return c;
      }
    }

    class My_Node 
    {
       String s_Name;
       
       public My_Node(String s){s_Name = s;}
        
       // Utilize toString so the a name can be displayed in the tree
       public String toString(){ return s_Name;}
    }
    
    TreeSelectionListener tsl = new TreeSelectionListener() {
       public void valueChanged(TreeSelectionEvent e) {
          // Get the selected path from the event
          TreePath path = e.getPath();
          int cnt = path.getPathCount();
          String s = "";
            
          for ( int i = 0 ; i < cnt; i++) {
             s += path.getPathComponent(i).toString();
                if (i+1 != cnt) s += "#";
          }
          jtf_Tree_Path.setText(s);
       }
   };
}