Java Tutorial/Swing/TreeModel

Expand All for a tree path

/*
 *  soapUI, copyright (C) 2004-2009 eviware.ru 
 *
 *  soapUI is free software; you can redistribute it and/or modify it under the 
 *  terms of version 2.1 of the GNU Lesser General Public License as published by 
 *  the Free Software Foundation.
 *
 *  soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
 *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
 *  See the GNU Lesser General Public License for more details at gnu.org.
 */
import java.util.Enumeration;
import javax.swing.JTree;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
public class TreeUtils {
  public static void expandAll(JTree tree, TreePath parent, boolean expand) {
    // Traverse children
    TreeNode node = (TreeNode) parent.getLastPathComponent();
    if (node.getChildCount() >= 0) {
      for (Enumeration e = node.children(); e.hasMoreElements();) {
        TreeNode n = (TreeNode) e.nextElement();
        TreePath path = parent.pathByAddingChild(n);
        expandAll(tree, path, expand);
      }
    }
    // Expansion or collapse must be done bottom-up
    if (expand) {
      tree.expandPath(parent);
    } else {
      tree.collapsePath(parent);
    }
  }
}

Genealogy Tree

/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*
 * A 1.4 example that uses the following files:
 *    GenealogyModel.java
 *    Person.java
 *
 * Based on an example provided by tutorial reader Olivier Berlanger.
 */
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import javax.swing.ButtonGroup;
import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
public class GenealogyExample extends JPanel implements ActionListener {
  GenealogyTree tree;
  private static String SHOW_ANCESTOR_CMD = "showAncestor";
  public GenealogyExample() {
    super(new BorderLayout());
    // Construct the panel with the toggle buttons.
    JRadioButton showDescendant = new JRadioButton("Show descendants", true);
    final JRadioButton showAncestor = new JRadioButton("Show ancestors");
    ButtonGroup bGroup = new ButtonGroup();
    bGroup.add(showDescendant);
    bGroup.add(showAncestor);
    showDescendant.addActionListener(this);
    showAncestor.addActionListener(this);
    showAncestor.setActionCommand(SHOW_ANCESTOR_CMD);
    JPanel buttonPanel = new JPanel();
    buttonPanel.add(showDescendant);
    buttonPanel.add(showAncestor);
    // Construct the tree.
    tree = new GenealogyTree(getGenealogyGraph());
    JScrollPane scrollPane = new JScrollPane(tree);
    scrollPane.setPreferredSize(new Dimension(200, 200));
    // Add everything to this panel.
    add(buttonPanel, BorderLayout.PAGE_START);
    add(scrollPane, BorderLayout.CENTER);
  }
  /**
   * Required by the ActionListener interface. Handle events on the
   * showDescendant and showAncestore buttons.
   */
  public void actionPerformed(ActionEvent ae) {
    if (ae.getActionCommand() == SHOW_ANCESTOR_CMD) {
      tree.showAncestor(true);
    } else {
      tree.showAncestor(false);
    }
  }
  /**
   * Constructs the genealogy graph used by the model.
   */
  public Person getGenealogyGraph() {
    // the greatgrandparent generation
    Person a1 = new Person("Jack (great-granddaddy)");
    Person a2 = new Person("Jean (great-granny)");
    Person a3 = new Person("Albert (great-granddaddy)");
    Person a4 = new Person("Rae (great-granny)");
    Person a5 = new Person("Paul (great-granddaddy)");
    Person a6 = new Person("Josie (great-granny)");
    // the grandparent generation
    Person b1 = new Person("Peter (grandpa)");
    Person b2 = new Person("Zoe (grandma)");
    Person b3 = new Person("Simon (grandpa)");
    Person b4 = new Person("James (grandpa)");
    Person b5 = new Person("Bertha (grandma)");
    Person b6 = new Person("Veronica (grandma)");
    Person b7 = new Person("Anne (grandma)");
    Person b8 = new Person("Renee (grandma)");
    Person b9 = new Person("Joseph (grandpa)");
    // the parent generation
    Person c1 = new Person("Isabelle (mom)");
    Person c2 = new Person("Frank (dad)");
    Person c3 = new Person("Louis (dad)");
    Person c4 = new Person("Laurence (dad)");
    Person c5 = new Person("Valerie (mom)");
    Person c6 = new Person("Marie (mom)");
    Person c7 = new Person("Helen (mom)");
    Person c8 = new Person("Mark (dad)");
    Person c9 = new Person("Oliver (dad)");
    // the youngest generation
    Person d1 = new Person("Clement (boy)");
    Person d2 = new Person("Colin (boy)");
    Person.linkFamily(a1, a2, new Person[] { b1, b2, b3, b4 });
    Person.linkFamily(a3, a4, new Person[] { b5, b6, b7 });
    Person.linkFamily(a5, a6, new Person[] { b8, b9 });
    Person.linkFamily(b3, b6, new Person[] { c1, c2, c3 });
    Person.linkFamily(b4, b5, new Person[] { c4, c5, c6 });
    Person.linkFamily(b8, b7, new Person[] { c7, c8, c9 });
    Person.linkFamily(c4, c7, new Person[] { d1, d2 });
    return a1;
  }
  /**
   * Create the GUI and show it. For thread safety, this method should be
   * invoked from the event-dispatching thread.
   */
  private static void createAndShowGUI() {
    // Create and set up the window.
    JFrame frame = new JFrame("GenealogyExample");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    // Create and set up the content pane.
    GenealogyExample newContentPane = new GenealogyExample();
    newContentPane.setOpaque(true); // content panes must be opaque
    frame.setContentPane(newContentPane);
    // Display the window.
    frame.pack();
    frame.setVisible(true);
  }
  public static void main(String[] args) {
    // Schedule a job for the event-dispatching thread:
    // creating and showing this application"s GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        createAndShowGUI();
      }
    });
  }
}
/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *  - Neither the name of Sun Microsystems nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
class Person {
  Person father;
  Person mother;
  Vector<Person> children;
  private String name;
  public Person(String name) {
    this.name = name;
    mother = father = null;
    children = new Vector<Person>();
  }
  /**
   * Link together all members of a family.
   * 
   * @param pa
   *            the father
   * @param ma
   *            the mother
   * @param kids
   *            the children
   */
  public static void linkFamily(Person pa, Person ma, Person[] kids) {
    for (Person kid : kids) {
      pa.children.addElement(kid);
      ma.children.addElement(kid);
      kid.father = pa;
      kid.mother = ma;
    }
  }
  // / getter methods ///////////////////////////////////
  public String toString() {
    return name;
  }
  public String getName() {
    return name;
  }
  public Person getFather() {
    return father;
  }
  public Person getMother() {
    return mother;
  }
  public int getChildCount() {
    return children.size();
  }
  public Person getChildAt(int i) {
    return (Person) children.elementAt(i);
  }
  public int getIndexOfChild(Person kid) {
    return children.indexOf(kid);
  }
}
/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *  - Neither the name of Sun Microsystems nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
class GenealogyTree extends JTree {
  GenealogyModel model;
  public GenealogyTree(Person graphNode) {
    super(new GenealogyModel(graphNode));
    getSelectionModel().setSelectionMode(
        TreeSelectionModel.SINGLE_TREE_SELECTION);
    DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
    Icon personIcon = null;
    renderer.setLeafIcon(personIcon);
    renderer.setClosedIcon(personIcon);
    renderer.setOpenIcon(personIcon);
    setCellRenderer(renderer);
  }
  /**
   * Get the selected item in the tree, and call showAncestor with this item on
   * the model.
   */
  public void showAncestor(boolean b) {
    Object newRoot = null;
    TreePath path = getSelectionModel().getSelectionPath();
    if (path != null) {
      newRoot = path.getLastPathComponent();
    }
    ((GenealogyModel) getModel()).showAncestor(b, newRoot);
  }
}
/*
 * Copyright (c) 1995 - 2008 Sun Microsystems, Inc. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  - Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *  - Neither the name of Sun Microsystems nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
class GenealogyModel implements TreeModel {
  private boolean showAncestors;
  private Vector<TreeModelListener> treeModelListeners = new Vector<TreeModelListener>();
  private Person rootPerson;
  public GenealogyModel(Person root) {
    showAncestors = false;
    rootPerson = root;
  }
  /**
   * Used to toggle between show ancestors/show descendant and to change the
   * root of the tree.
   */
  public void showAncestor(boolean b, Object newRoot) {
    showAncestors = b;
    Person oldRoot = rootPerson;
    if (newRoot != null) {
      rootPerson = (Person) newRoot;
    }
    fireTreeStructureChanged(oldRoot);
  }
  // ////////////// Fire events //////////////////////////////////////////////
  /**
   * The only event raised by this model is TreeStructureChanged with the root
   * as path, i.e. the whole tree has changed.
   */
  protected void fireTreeStructureChanged(Person oldRoot) {
    int len = treeModelListeners.size();
    TreeModelEvent e = new TreeModelEvent(this, new Object[] { oldRoot });
    for (TreeModelListener tml : treeModelListeners) {
      tml.treeStructureChanged(e);
    }
  }
  // ////////////// TreeModel interface implementation ///////////////////////
  /**
   * Adds a listener for the TreeModelEvent posted after the tree changes.
   */
  public void addTreeModelListener(TreeModelListener l) {
    treeModelListeners.addElement(l);
  }
  /**
   * Returns the child of parent at index index in the parent"s child array.
   */
  public Object getChild(Object parent, int index) {
    Person p = (Person) parent;
    if (showAncestors) {
      if ((index > 0) && (p.getFather() != null)) {
        return p.getMother();
      }
      return p.getFather();
    }
    return p.getChildAt(index);
  }
  /**
   * Returns the number of children of parent.
   */
  public int getChildCount(Object parent) {
    Person p = (Person) parent;
    if (showAncestors) {
      int count = 0;
      if (p.getFather() != null) {
        count++;
      }
      if (p.getMother() != null) {
        count++;
      }
      return count;
    }
    return p.getChildCount();
  }
  /**
   * Returns the index of child in parent.
   */
  public int getIndexOfChild(Object parent, Object child) {
    Person p = (Person) parent;
    if (showAncestors) {
      int count = 0;
      Person father = p.getFather();
      if (father != null) {
        count++;
        if (father == child) {
          return 0;
        }
      }
      if (p.getMother() != child) {
        return count;
      }
      return -1;
    }
    return p.getIndexOfChild((Person) child);
  }
  /**
   * Returns the root of the tree.
   */
  public Object getRoot() {
    return rootPerson;
  }
  /**
   * Returns true if node is a leaf.
   */
  public boolean isLeaf(Object node) {
    Person p = (Person) node;
    if (showAncestors) {
      return ((p.getFather() == null) && (p.getMother() == null));
    }
    return p.getChildCount() == 0;
  }
  /**
   * Removes a listener previously added with addTreeModelListener().
   */
  public void removeTreeModelListener(TreeModelListener l) {
    treeModelListeners.removeElement(l);
  }
  /**
   * Messaged when the user has altered the value for the item identified by
   * path to newValue. Not used by this model.
   */
  public void valueForPathChanged(TreePath path, Object newValue) {
    System.out
        .println("*** valueForPathChanged : " + path + " --> " + newValue);
  }
}

Get tree path from TreeNode

import java.util.ArrayList;
import java.util.List;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
public class Utils {
  public static TreePath getPath(TreeNode treeNode) {
    List<Object> nodes = new ArrayList<Object>();
    if (treeNode != null) {
      nodes.add(treeNode);
      treeNode = treeNode.getParent();
      while (treeNode != null) {
        nodes.add(0, treeNode);
        treeNode = treeNode.getParent();
      }
    }
    return nodes.isEmpty() ? null : new TreePath(nodes.toArray());
  }
}

implements TreeModel

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Enumeration;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.UIDefaults;
import javax.swing.UIManager;
import javax.swing.WindowConstants;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
public class UIDefaultsTreeModel implements TreeModel {
  DefaultTreeModel innerModel;
  DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode("UIDefaults");
  DefaultMutableTreeNode colorNode = new DefaultMutableTreeNode("Color Resources");
  DefaultMutableTreeNode borderNode = new DefaultMutableTreeNode("Border Resources");
  DefaultMutableTreeNode fontNode = new DefaultMutableTreeNode("Font Resources");
  DefaultMutableTreeNode iconNode = new DefaultMutableTreeNode("Icon Resources");
  DefaultMutableTreeNode otherNode = new DefaultMutableTreeNode("Other Resources");
  public UIDefaultsTreeModel() {
    innerModel = new DefaultTreeModel(rootNode);
    innerModel.insertNodeInto(colorNode, rootNode, 0);
    innerModel.insertNodeInto(borderNode, rootNode, 1);
    innerModel.insertNodeInto(fontNode, rootNode, 2);
    innerModel.insertNodeInto(iconNode, rootNode, 3);
    innerModel.insertNodeInto(otherNode, rootNode, 4);
    UIDefaults defaults = UIManager.getDefaults();
    Enumeration elems = defaults.keys();
    String keyName;
    Object valueForKey;
    while (elems.hasMoreElements()) {
      DefaultMutableTreeNode newKeyNode;
      DefaultMutableTreeNode newValueNode;
      try {
        keyName = elems.nextElement().toString();
        valueForKey = defaults.get(keyName);
        newKeyNode = new DefaultMutableTreeNode(keyName);
        newValueNode = new DefaultMutableTreeNode(valueForKey);
        if (valueForKey instanceof java.awt.Color) {
          innerModel.insertNodeInto(newKeyNode, colorNode, 0);
        } else if (valueForKey instanceof javax.swing.border.Border) {
          innerModel.insertNodeInto(newKeyNode, borderNode, 0);
        } else if (valueForKey instanceof java.awt.Font) {
          innerModel.insertNodeInto(newKeyNode, fontNode, 0);
        } else if (valueForKey instanceof javax.swing.Icon) {
          innerModel.insertNodeInto(newKeyNode, iconNode, 0);
        } else {
          innerModel.insertNodeInto(newKeyNode, otherNode, 0);
        }
        innerModel.insertNodeInto(newValueNode, newKeyNode, 0);
      } catch (NullPointerException e) {
      }
    }
  }
  public Object getRoot() {
    return innerModel.getRoot();
  }
  public Object getChild(Object parm1, int parm2) {
    return innerModel.getChild(parm1, parm2);
  }
  public int getChildCount(Object parm1) {
    return innerModel.getChildCount(parm1);
  }
  public boolean isLeaf(Object parm1) {
    return innerModel.isLeaf(parm1);
  }
  public void valueForPathChanged(TreePath parm1, Object parm2) {
    innerModel.valueForPathChanged(parm1, parm2);
  }
  public int getIndexOfChild(Object parm1, Object parm2) {
    return innerModel.getIndexOfChild(parm1, parm2);
  }
  public void addTreeModelListener(TreeModelListener parm1) {
    innerModel.addTreeModelListener(parm1);
  }
  public void removeTreeModelListener(TreeModelListener parm1) {
    innerModel.removeTreeModelListener(parm1);
  }
  public static void main(String[] args) {
    JFrame treeFrame1 = new JFrame();
    JScrollPane jScrollPane1 = new JScrollPane();
    JTree jTree1 = new JTree(new UIDefaultsTreeModel());
    treeFrame1.setSize(new Dimension(400, 300));
    treeFrame1.addWindowListener(new WindowAdapter() {
      public void windowClosed(WindowEvent e) {
        System.exit(0);
      }
    });
    treeFrame1.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    treeFrame1.getContentPane().add(jScrollPane1, BorderLayout.CENTER);
    jScrollPane1.getViewport().add(jTree1, null);
    treeFrame1.setVisible(true);
  }
}

JTree.getModel().addTreeModelListener(new TreeModelListener())

import java.awt.Dimension;
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
public class Main {
  public static void main(String args[]) {
    JFrame f = new JFrame("JTree Demo");
    f.setSize(260, 240);
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
    DefaultMutableTreeNode aNode = new DefaultMutableTreeNode("A");
    root.add(aNode);
    DefaultMutableTreeNode bNode = new DefaultMutableTreeNode("B");
    aNode.add(bNode);
    DefaultMutableTreeNode cNode = new DefaultMutableTreeNode("C");
    aNode.add(cNode);
    cNode.add(new DefaultMutableTreeNode("D"));
    cNode.add(new DefaultMutableTreeNode("E"));
    DefaultMutableTreeNode fNode = new DefaultMutableTreeNode("F");
    root.add(fNode);
    DefaultMutableTreeNode gNode = new DefaultMutableTreeNode("G");
    fNode.add(gNode);
    fNode.add(new DefaultMutableTreeNode("H"));
    gNode.add(new DefaultMutableTreeNode("I"));
    JTree jtree = new JTree(root);
    jtree.setEditable(true);
    TreeSelectionModel tsm = jtree.getSelectionModel();
    tsm.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    jtree.addTreeExpansionListener(new TreeExpansionListener() {
      public void treeExpanded(TreeExpansionEvent tee) {
        TreePath tp = tee.getPath();
        System.out.println("Expansion: " + tp.getLastPathComponent());
      }
      public void treeCollapsed(TreeExpansionEvent tee) {
        TreePath tp = tee.getPath();
        System.out.println("Collapse: " + tp.getLastPathComponent());
      }
    });
    jtree.addTreeSelectionListener(new TreeSelectionListener() {
      public void valueChanged(TreeSelectionEvent tse) {
        TreePath tp = tse.getPath();
        System.out.println("Selection event: " + tp.getLastPathComponent());
      }
    });
    jtree.getModel().addTreeModelListener(new TreeModelListener() {
      public void treeNodesChanged(TreeModelEvent tme) {
        TreePath tp = tme.getTreePath();
        Object[] children = tme.getChildren();
        DefaultMutableTreeNode changedNode;
        if (children != null)
          changedNode = (DefaultMutableTreeNode) children[0];
        else
          changedNode = (DefaultMutableTreeNode) tp.getLastPathComponent();
        System.out.println("Model change path: " + tp + "New data: "
            + changedNode.getUserObject());
      }
      public void treeNodesInserted(TreeModelEvent tme) {
      }
      public void treeNodesRemoved(TreeModelEvent tme) {
      }
      public void treeStructureChanged(TreeModelEvent tme) {
      }
    });
    f.add(new JScrollPane(jtree));
    f.setVisible(true);
  }
}

Tree node editing with DefaultTreeModel

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreePath;
public class MainClass {
  public static void main(String[] args) {
    MutableTreeNode root = new DefaultMutableTreeNode("A");
    MutableTreeNode beams = new DefaultMutableTreeNode("B");
    MutableTreeNode gears = new DefaultMutableTreeNode("C");
    root.insert(beams, 0);
    root.insert(gears, 1);
    beams.insert(new DefaultMutableTreeNode("4 "), 0);
    beams.insert(new DefaultMutableTreeNode("6 "), 1);
    beams.insert(new DefaultMutableTreeNode("8 "), 2);
    beams.insert(new DefaultMutableTreeNode("12 "), 3);
    gears.insert(new DefaultMutableTreeNode("8t"), 0);
    gears.insert(new DefaultMutableTreeNode("24t"), 1);
    gears.insert(new DefaultMutableTreeNode("40t"), 2);
    final DefaultTreeModel model = new DefaultTreeModel(root);
    final JTree tree = new JTree(model);
    final JTextField nameField = new JTextField("16t");
    final JButton button = new JButton("Add a part");
    button.setEnabled(false);
    button.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        TreePath tp = tree.getSelectionPath();
        MutableTreeNode insertNode = (MutableTreeNode) tp.getLastPathComponent();
        int insertIndex = 0;
        if (insertNode.getParent() != null) {
          MutableTreeNode parent = (MutableTreeNode) insertNode.getParent();
          insertIndex = parent.getIndex(insertNode) + 1;
          insertNode = parent;
        }
        MutableTreeNode node = new DefaultMutableTreeNode(nameField.getText());
        model.insertNodeInto(node, insertNode, insertIndex);
      }
    });
    JPanel addPanel = new JPanel(new GridLayout(2, 1));
    addPanel.add(nameField);
    addPanel.add(button);
    tree.addTreeSelectionListener(new TreeSelectionListener() {
      public void valueChanged(TreeSelectionEvent e) {
        TreePath tp = e.getNewLeadSelectionPath();
        button.setEnabled(tp != null);
      }
    });
    JFrame frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(200, 200);
    frame.getContentPane().add(new JScrollPane(tree));
    frame.getContentPane().add(addPanel, BorderLayout.SOUTH);
    frame.setVisible(true);
  }
}