javax.swing.tree

Class DefaultTreeModel

Table des matières
  • All Implemented Interfaces:
    Serializable, TreeModel

    public class DefaultTreeModel
extends Object
implements Serializable, TreeModel
    A simple tree data model that uses TreeNodes. For further information and examples that use DefaultTreeModel, see How to Use Trees in The Java Tutorial.

    Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeansTM has been added to the java.beans package. Please see XMLEncoder.

    • Field Detail

      • root

        protected TreeNode root
        Root of the tree.

      • asksAllowsChildren

        protected boolean asksAllowsChildren
        Determines how the isLeaf method figures out if a node is a leaf node. If true, a node is a leaf node if it does not allow children. (If it allows children, it is not a leaf node, even if no children are present.) That lets you distinguish between folder nodes and file nodes in a file system, for example.

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

        See Also:
        TreeNode.getAllowsChildren(), TreeModel.isLeaf(java.lang.Object), setAsksAllowsChildren(boolean)

    • Constructor Detail

      • DefaultTreeModel

        public DefaultTreeModel(TreeNode root,
                boolean 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
        See Also:
        asksAllowsChildren

    • Method Detail

      • setAsksAllowsChildren

        public void setAsksAllowsChildren(boolean 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.

      • asksAllowsChildren

        public boolean asksAllowsChildren()
        Tells how leaf nodes are determined.
        Returns:
        true if only nodes which do not allow children are leaf nodes, false if nodes which have no children (even if allowed) are leaf nodes
        See Also:
        asksAllowsChildren

      • setRoot

        public void setRoot(TreeNode root)
        Sets the root to root. A null root implies the tree is to display nothing, and is legal.

      • getRoot

        public Object getRoot()
        Returns the root of the tree. Returns null only if the tree has no nodes.
        Specified by:
        getRoot in interface TreeModel
        Returns:
        the root of the tree

      • getIndexOfChild

        public int getIndexOfChild(Object parent,
                  Object child)
        Returns the index of child in parent. If either the parent or child is null, returns -1.
        Specified by:
        getIndexOfChild in interface TreeModel
        Parameters:
        parent - a note in the tree, obtained from this data source
        child - the node we are interested in
        Returns:
        the index of the child in the parent, or -1 if either the parent or the child is null

      • getChild

        public Object getChild(Object parent,
              int 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)).
        Specified by:
        getChild in interface TreeModel
        Parameters:
        parent - a node in the tree, obtained from this data source
        Returns:
        the child of parent at index index

      • getChildCount

        public int getChildCount(Object parent)
        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.
        Specified by:
        getChildCount in interface TreeModel
        Parameters:
        parent - a node in the tree, obtained from this data source
        Returns:
        the number of children of the node parent

      • reload

        public void reload()
        Invoke this method if you've modified the TreeNodes upon which this model depends. The model will notify all of its listeners that the model has changed.

      • valueForPathChanged

        public void valueForPathChanged(TreePath path,
                       Object newValue)
        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.
        Specified by:
        valueForPathChanged in interface TreeModel
        Parameters:
        path - path to the node that the user has altered
        newValue - the new value from the TreeCellEditor

      • insertNodeInto

        public void insertNodeInto(MutableTreeNode newChild,
                  MutableTreeNode parent,
                  int index)
        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.

      • removeNodeFromParent

        public void removeNodeFromParent(MutableTreeNode node)
        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.

      • nodeChanged

        public void nodeChanged(TreeNode node)
        Invoke this method after you've changed how node is to be represented in the tree.

      • reload

        public void reload(TreeNode node)
        Invoke this method if you've modified the TreeNodes upon which this model depends. The model will notify all of its listeners that the model has changed below the given node.
        Parameters:
        node - the node below which the model has changed

      • nodesWereInserted

        public void nodesWereInserted(TreeNode node,
                     int[] childIndices)
        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.

      • nodesWereRemoved

        public void nodesWereRemoved(TreeNode node,
                    int[] childIndices,
                    Object[] 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.

      • nodesChanged

        public void nodesChanged(TreeNode node,
                int[] childIndices)
        Invoke this method after you've changed how the children identified by childIndicies are to be represented in the tree.

      • nodeStructureChanged

        public void nodeStructureChanged(TreeNode node)
        Invoke this method if you've totally changed the children of node and its childrens children... This will post a treeStructureChanged event.

      • getPathToRoot

        public TreeNode[] getPathToRoot(TreeNode aNode)
        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.
        Parameters:
        aNode - the TreeNode to get the path for

      • getPathToRoot

        protected TreeNode[] getPathToRoot(TreeNode aNode,
                       int depth)
        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.
        Parameters:
        aNode - the TreeNode to get the path for
        depth - an int giving the number of steps already taken towards the root (on recursive calls), used to size the returned array
        Returns:
        an array of TreeNodes giving the path from the root to the specified node

      • fireTreeNodesChanged

        protected void fireTreeNodesChanged(Object source,
                        Object[] path,
                        int[] childIndices,
                        Object[] children)
        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.
        Parameters:
        source - the source of the TreeModelEvent; typically this
        path - the path to the parent of the nodes that changed; use null to identify the root has changed
        childIndices - the indices of the changed elements
        children - the changed elements

      • fireTreeNodesInserted

        protected void fireTreeNodesInserted(Object source,
                         Object[] path,
                         int[] childIndices,
                         Object[] children)
        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.
        Parameters:
        source - the source of the TreeModelEvent; typically this
        path - the path to the parent the nodes were added to
        childIndices - the indices of the new elements
        children - the new elements

      • fireTreeNodesRemoved

        protected void fireTreeNodesRemoved(Object source,
                        Object[] path,
                        int[] childIndices,
                        Object[] children)
        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.
        Parameters:
        source - the source of the TreeModelEvent; typically this
        path - the path to the parent the nodes were removed from
        childIndices - the indices of the removed elements
        children - the removed elements

      • fireTreeStructureChanged

        protected void fireTreeStructureChanged(Object source,
                            Object[] path,
                            int[] childIndices,
                            Object[] children)
        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.
        Parameters:
        source - the source of the TreeModelEvent; typically this
        path - the path to the parent of the structure that has changed; use null to identify the root has changed
        childIndices - the indices of the affected elements
        children - the affected elements

      • getListeners

        public <T extends EventListener> T[] getListeners(Class<T> 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.
        Parameters:
        listenerType - the type of listeners requested; this parameter should specify an interface that descends from java.util.EventListener
        Returns:
        an array of all objects registered as FooListeners on this component, or an empty array if no such listeners have been added
        Throws:
        ClassCastException - if listenerType doesn't specify a class or interface that implements java.util.EventListener
        Since:
        1.3
        See Also:
        getTreeModelListeners()

Traduction non disponible

Les API Java ne sont pas encore traduites en français sur l'infobrol. Seule la version anglaise est disponible pour l'instant.

Version en cache

22/12/2024 09:52:43 Cette version de la page est en cache (à la date du 22/12/2024 09:52:43) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.

Document créé le 31/08/2006, dernière modification le 04/03/2020
Source du document imprimé : https://www.gaudry.be/java-api-rf-javax/swing/tree/DefaultTreeModel.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.

Références

  1. Consulter le document html Langue du document :fr Manuel PHP : https://docs.oracle.com, DefaultTreeModel

Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.

Table des matières Haut