If this value is false, then any node which has no children is a leaf node, and any node may acquire children.

Also see:

TreeNode#getAllowsChildren
TreeModel#isLeaf
setAsksAllowsChildren

 public DefaultTreeModel(TreeNode root) 
{
        this(root, false);
}

Creates a tree in which any node can have children.

Parameters:

root - a TreeNode object that is the root of the tree

Also see:

DefaultTreeModel(TreeNode, boolean)

 public DefaultTreeModel(TreeNode root,
    boolean asksAllowsChildren) 
{
        super();
        this.root = root;
        this.asksAllowsChildren = asksAllowsChildren;
}

Creates a tree specifying whether any node can have children, or whether only certain nodes can have children.

Parameters:

root - a TreeNode object that is the root of the tree

asksAllowsChildren - a boolean, false if any node can have children, true if each node is asked to see if it can have children

Also see:

asksAllowsChildren

 public  void addTreeModelListener(TreeModelListener l) 
{
        listenerList.add(TreeModelListener.class, l);
}

Adds a listener for the TreeModelEvent posted after the tree changes.

 public boolean asksAllowsChildren() 
{
        return asksAllowsChildren;
}

Tells how leaf nodes are determined.

 protected  void fireTreeNodesChanged(Object source,
    Object[] path,
    int[] childIndices,
    Object[] children) 
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i >=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path,
                                           childIndices, children);
                ((TreeModelListener)listeners[i+1]).treeNodesChanged(e);
            }
        }
}

Notifies all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.

 protected  void fireTreeNodesInserted(Object source,
    Object[] path,
    int[] childIndices,
    Object[] children) 
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i >=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path,
                                           childIndices, children);
                ((TreeModelListener)listeners[i+1]).treeNodesInserted(e);
            }
        }
}

Notifies all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.

 protected  void fireTreeNodesRemoved(Object source,
    Object[] path,
    int[] childIndices,
    Object[] children) 
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i >=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path,
                                           childIndices, children);
                ((TreeModelListener)listeners[i+1]).treeNodesRemoved(e);
            }
        }
}

Notifies all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.

 protected  void fireTreeStructureChanged(Object source,
    Object[] path,
    int[] childIndices,
    Object[] children) 
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i >=0; i-=2) {
            if (listeners[i]==TreeModelListener.class) {
                // Lazily create the event:
                if (e == null)
                    e = new TreeModelEvent(source, path,
                                           childIndices, children);
                ((TreeModelListener)listeners[i+1]).treeStructureChanged(e);
            }
        }
}

Notifies all listeners that have registered interest for notification on this event type. The event instance is lazily created using the parameters passed into the fire method.

 public Object getChild(Object parent,
    int index) 
{
        return ((TreeNode)parent).getChildAt(index);
}

Returns the child of parent at index index in the parent's child array. parent must be a node previously obtained from this data source. This should not return null if index is a valid index for parent (that is index >= 0 && index < getChildCount(parent)).

 public int getChildCount(Object parent) 
{
        return ((TreeNode)parent).getChildCount();
}

Returns the number of children of parent. Returns 0 if the node is a leaf or if it has no children. parent must be a node previously obtained from this data source.

 public int getIndexOfChild(Object parent,
    Object child) 
{
        if(parent == null || child == null)
            return -1;
        return ((TreeNode)parent).getIndex((TreeNode)child);
}

Returns the index of child in parent. If either the parent or child is null, returns -1.

 public T[] getListeners(Class<T> listenerType) 
{
        return listenerList.getListeners(listenerType);
}

Returns an array of all the objects currently registered as FooListeners upon this model. FooListeners are registered using the addFooListener method.

You can specify the listenerType argument with a class literal, such as FooListener.class. For example, you can query a DefaultTreeModel m for its tree model listeners with the following code:

TreeModelListener[] tmls = (TreeModelListener[])(m.getListeners(TreeModelListener.class));

If no such listeners exist, this method returns an empty array.

 public TreeNode[] getPathToRoot(TreeNode aNode) 
{
        return getPathToRoot(aNode, 0);
}

Builds the parents of node up to and including the root node, where the original node is the last element in the returned array. The length of the returned array gives the node's depth in the tree.

 protected TreeNode[] getPathToRoot(TreeNode aNode,
    int depth) 
{
        TreeNode[]              retNodes;
        // This method recurses, traversing towards the root in order
        // size the array. On the way back, it fills in the nodes,
        // starting from the root and working back to the original node.
        /* Check for null, in case someone passed in a null node, or
           they passed in an element that isn't rooted at root. */
        if(aNode == null) {
            if(depth == 0)
                return null;
            else
                retNodes = new TreeNode[depth];
        }
        else {
            depth++;
            if(aNode == root)
                retNodes = new TreeNode[depth];
            else
                retNodes = getPathToRoot(aNode.getParent(), depth);
            retNodes[retNodes.length - depth] = aNode;
        }
        return retNodes;
}

Builds the parents of node up to and including the root node, where the original node is the last element in the returned array. The length of the returned array gives the node's depth in the tree.

 public Object getRoot() 
{
        return root;
}

Returns the root of the tree. Returns null only if the tree has no nodes.

 public TreeModelListener[] getTreeModelListeners() 
{
        return listenerList.getListeners(TreeModelListener.class);
}

Returns an array of all the tree model listeners registered on this model.

 public  void insertNodeInto(MutableTreeNode newChild,
    MutableTreeNode parent,
    int index) 
{
        parent.insert(newChild, index);
        int[]           newIndexs = new int[1];
        newIndexs[0] = index;
        nodesWereInserted(parent, newIndexs);
}

Invoked this to insert newChild at location index in parents children. This will then message nodesWereInserted to create the appropriate event. This is the preferred way to add children as it will create the appropriate event.

 public boolean isLeaf(Object node) 
{
        if(asksAllowsChildren)
            return !((TreeNode)node).getAllowsChildren();
        return ((TreeNode)node).isLeaf();
}

Returns whether the specified node is a leaf node. The way the test is performed depends on the askAllowsChildren setting.

 public  void nodeChanged(TreeNode node) 
{
        if(listenerList != null && node != null) {
            TreeNode         parent = node.getParent();
            if(parent != null) {
                int        anIndex = parent.getIndex(node);
                if(anIndex != -1) {
                    int[]        cIndexs = new int[1];
                    cIndexs[0] = anIndex;
                    nodesChanged(parent, cIndexs);
                }
            }
            else if (node == getRoot()) {
                nodesChanged(node, null);
            }
        }
}

Invoke this method after you've changed how node is to be represented in the tree.

 public  void nodeStructureChanged(TreeNode node) 
{
        if(node != null) {
           fireTreeStructureChanged(this, getPathToRoot(node), null, null);
        }
}

Invoke this method if you've totally changed the children of node and its childrens children... This will post a treeStructureChanged event.

 public  void nodesChanged(TreeNode node,
    int[] childIndices) 
{
        if(node != null) {
            if (childIndices != null) {
                int            cCount = childIndices.length;
                if(cCount  > 0) {
                    Object[]       cChildren = new Object[cCount];
                    for(int counter = 0; counter <  cCount; counter++)
                        cChildren[counter] = node.getChildAt
                            (childIndices[counter]);
                    fireTreeNodesChanged(this, getPathToRoot(node),
                                         childIndices, cChildren);
                }
            }
            else if (node == getRoot()) {
                fireTreeNodesChanged(this, getPathToRoot(node), null, null);
            }
        }
}

Invoke this method after you've changed how the children identified by childIndicies are to be represented in the tree.

 public  void nodesWereInserted(TreeNode node,
    int[] childIndices) 
{
        if(listenerList != null && node != null && childIndices != null
           && childIndices.length  > 0) {
            int               cCount = childIndices.length;
            Object[]          newChildren = new Object[cCount];
            for(int counter = 0; counter <  cCount; counter++)
                newChildren[counter] = node.getChildAt(childIndices[counter]);
            fireTreeNodesInserted(this, getPathToRoot(node), childIndices,
                                  newChildren);
        }
}

Invoke this method after you've inserted some TreeNodes into node. childIndices should be the index of the new elements and must be sorted in ascending order.

 public  void nodesWereRemoved(TreeNode node,
    int[] childIndices,
    Object[] removedChildren) 
{
        if(node != null && childIndices != null) {
            fireTreeNodesRemoved(this, getPathToRoot(node), childIndices,
                                 removedChildren);
        }
}

Invoke this method after you've removed some TreeNodes from node. childIndices should be the index of the removed elements and must be sorted in ascending order. And removedChildren should be the array of the children objects that were removed.

 public  void reload() 
{
        reload(root);
}

Invoke this method if you've modified the {@code TreeNode}s upon which this model depends. The model will notify all of its listeners that the model has changed.

 public  void reload(TreeNode node) 
{
        if(node != null) {
            fireTreeStructureChanged(this, getPathToRoot(node), null, null);
        }
}

Invoke this method if you've modified the {@code TreeNode}s upon which this model depends. The model will notify all of its listeners that the model has changed below the given node.

 public  void removeNodeFromParent(MutableTreeNode node) 
{
        MutableTreeNode         parent = (MutableTreeNode)node.getParent();
        if(parent == null)
            throw new IllegalArgumentException("node does not have a parent.");
        int[]            childIndex = new int[1];
        Object[]         removedArray = new Object[1];
        childIndex[0] = parent.getIndex(node);
        parent.remove(childIndex[0]);
        removedArray[0] = node;
        nodesWereRemoved(parent, childIndex, removedArray);
}

Message this to remove node from its parent. This will message nodesWereRemoved to create the appropriate event. This is the preferred way to remove a node as it handles the event creation for you.

 public  void removeTreeModelListener(TreeModelListener l) 
{
        listenerList.remove(TreeModelListener.class, l);
}

Removes a listener previously added with addTreeModelListener().

 public  void setAsksAllowsChildren(boolean newValue) 
{
        asksAllowsChildren = newValue;
}

Sets whether or not to test leafness by asking getAllowsChildren() or isLeaf() to the TreeNodes. If newvalue is true, getAllowsChildren() is messaged, otherwise isLeaf() is messaged.

 public  void setRoot(TreeNode root) 
{
        Object oldRoot = this.root;
        this.root = root;
        if (root == null && oldRoot != null) {
            fireTreeStructureChanged(this, null);
        }
        else {
            nodeStructureChanged(root);
        }
}

Sets the root to root. A null root implies the tree is to display nothing, and is legal.

 public  void valueForPathChanged(TreePath path,
    Object newValue) 
{
        MutableTreeNode   aNode = (MutableTreeNode)path.getLastPathComponent();
        aNode.setUserObject(newValue);
        nodeChanged(aNode);
}

This sets the user object of the TreeNode identified by path and posts a node changed. If you use custom user objects in the TreeModel you're going to need to subclass this and set the user object of the changed node to something meaningful.