Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.jdesktop.swingx.treetable
Class DefaultTreeTableModel

    java.lang.Object
      org.jdesktop.swingx.treetable.AbstractTreeTableModel
          org.jdesktop.swingx.treetable.DefaultTreeTableModel

All Implemented Interfaces:
  javax.swing.tree.TreeModel, TreeTableModel

    public class DefaultTreeTableModel

extends AbstractTreeTableModel

`DefaultTreeTableModel` is a concrete implementation of `AbstractTreeTableModel` and is provided purely as a convenience for use with `TreeTableNode`s. Applications that use `JXTreeTable` without `TreeTableNode`s are expected to provide their own implementation of a `TreeTableModel`.

The `DefaultTreeTableModel` is designed to be used with `TreeTableNode`s. Specifically, users should extend `AbstractMutableTreeTableNode` to provide custom implementations for data display.

Users who do not provide a list of column identifiers must provide a root that contains at least one column. Without specified identifiers the model will attempt to calculate the columns required for display by querying the root node. Normally, the root node can be little more than a shell (in displays that hide it), but without identifiers, the model relies on the root node metadata for display.

Author:
  Ramesh Gupta, Karl Schaefer

Field Summary
`protected java.util.List<?>` | `columnIdentifiers` The `List` of column identifiers.

Fields inherited from class org.jdesktop.swingx.treetable.AbstractTreeTableModel
`modelSupport, root`

Constructor Summary
`DefaultTreeTableModel()` Creates a new `DefaultTreeTableModel` with a `null` root.
`DefaultTreeTableModel(TreeTableNode root)` Creates a new `DefaultTreeTableModel` with the specified `root`.
`DefaultTreeTableModel(TreeTableNode root, java.util.List<?> columnNames)` Creates a new `DefaultTreeTableModel` with the specified `root` and column names.

Method Summary
`java.lang.Object` | `getChild(java.lang.Object parent, int index)`
`int` | `getChildCount(java.lang.Object parent)`
`int` | `getColumnCount()` Returns the number of columns in the model.
`java.lang.String` | `getColumnName(int column)` Returns the name of the column at `columnIndex`.
`int` | `getIndexOfChild(java.lang.Object parent, java.lang.Object child)`
`TreeTableNode[]` | `getPathToRoot(TreeTableNode aNode)` Gets the path from the root to the specified node.
`TreeTableNode` | `getRoot()` Returns the root of the tree.
`java.lang.Object` | `getValueAt(java.lang.Object node, int column)` Gets the value for the `node` at `column`.
`void` | `insertNodeInto(MutableTreeTableNode newChild, MutableTreeTableNode parent, int index)` Invoked this to insert newChild at location index in parents children.
`boolean` | `isCellEditable(java.lang.Object node, int column)` Returns true if the cell for the `node` at `columnIndex` is editable.
`boolean` | `isLeaf(java.lang.Object node)` Returns `true` if `node` is a leaf.
`void` | `removeNodeFromParent(MutableTreeTableNode node)` Message this to remove node from its parent.
`void` | `setColumnIdentifiers(java.util.List<?> columnIdentifiers)` Replaces the column identifiers in the model.
`void` | `setRoot(TreeTableNode root)` Sets the root for this table model.
`void` | `setUserObject(TreeTableNode node, java.lang.Object userObject)` Sets the user object for a node.
`void` | `setValueAt(java.lang.Object value, java.lang.Object node, int column)` Sets the value for the `node` at `columnIndex` to `value`.
`void` | `valueForPathChanged(javax.swing.tree.TreePath path, java.lang.Object newValue)` Called when value for the item identified by path has been changed.

Methods inherited from class org.jdesktop.swingx.treetable.AbstractTreeTableModel
`addTreeModelListener, getColumnClass, getHierarchicalColumn, getTreeModelListeners, removeTreeModelListener`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### columnIdentifiers

    protected java.util.List<?> columnIdentifiers

  The `List` of column identifiers.

Constructor Detail

### DefaultTreeTableModel

    public DefaultTreeTableModel()

  Creates a new `DefaultTreeTableModel` with a `null` root.

### DefaultTreeTableModel

    public DefaultTreeTableModel(TreeTableNode root)

  Creates a new `DefaultTreeTableModel` with the specified `root`.

  Parameters:
    `root` - the root node of the tree

### DefaultTreeTableModel

    public DefaultTreeTableModel(TreeTableNode root,
                                 java.util.List<?> columnNames)

  Creates a new `DefaultTreeTableModel` with the specified `root` and column names.

  Parameters:
    `root` - the root node of the tree
    `columnNames` - the names of the columns used by this model
  See Also:
    `setColumnIdentifiers(List)`

Method Detail

### setColumnIdentifiers

    public void setColumnIdentifiers(java.util.List<?> columnIdentifiers)

  Replaces the column identifiers in the model. If the number of `newIdentifier`s is greater than the current number of columns, new columns are added to the end of each row in the model. If the number of `newIdentifier`s is less than the current number of columns, all the extra columns at the end of a row are discarded.

  Parameters:
    `columnIdentifiers` - vector of column identifiers. If `null`, set the model to zero columns

### getRoot

    public TreeTableNode getRoot()

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

  Specified by:
    `getRoot` in interface `javax.swing.tree.TreeModel`
  Overrides:
    `getRoot` in class `AbstractTreeTableModel`
  Returns:
    the root of the tree
  Throws:
    `java.lang.ClassCastException` - if `root` is not a `TreeTableNode`. Even though subclasses have direct access to `root`, they should avoid accessing it directly.
  See Also:
    `AbstractTreeTableModel.root`, `setRoot(TreeTableNode)`

### getValueAt

    public java.lang.Object getValueAt(java.lang.Object node,
                                       int column)

  Gets the value for the `node` at `column`.

  Parameters:
    `node` - the node whose value is to be queried
    `column` - the column whose value is to be queried
  Returns:
    the value Object at the specified cell
  Throws:
    `java.lang.IllegalArgumentException` - if `node` is not an instance of `TreeTableNode` or is not managed by this model, or `column` is not a valid column index
  See Also:
    `TreeTableModel.setValueAt(java.lang.Object, java.lang.Object, int)`, `TableModel.getValueAt(int, int)`

### setValueAt

    public void setValueAt(java.lang.Object value,
                           java.lang.Object node,
                           int column)

  Sets the value for the `node` at `columnIndex` to `value`.

  Specified by:
    `setValueAt` in interface `TreeTableModel`
  Overrides:
    `setValueAt` in class `AbstractTreeTableModel`
  Parameters:
    `value` - the new value
    `node` - the node whose value is to be changed
    `column` - the column whose value is to be changed
  See Also:
    `TreeTableModel.getValueAt(java.lang.Object, int)`, `AbstractTreeTableModel.isCellEditable(java.lang.Object, int)`, `TableModel.setValueAt(Object, int, int)`

### getColumnCount

    public int getColumnCount()

  Returns the number of columns in the model. A `JXTreeTable` uses this method to determine how many columns it should create and display by default.

  Returns:
    the number of columns in the model
  See Also:
    `TableModel.getColumnCount()`

### getColumnName

    public java.lang.String getColumnName(int column)

  Returns the name of the column at `columnIndex`. This is used to initialize the table's column header name. Note: this name does not need to be unique; two columns in a table can have the same name.

  Specified by:
    `getColumnName` in interface `TreeTableModel`
  Overrides:
    `getColumnName` in class `AbstractTreeTableModel`
  Parameters:
    `column` - the index of the column
  Returns:
    the name of the column
  See Also:
    `TableModel.getColumnName(int)`

### getChild

    public java.lang.Object getChild(java.lang.Object parent,
                                     int index)

### getChildCount

    public int getChildCount(java.lang.Object parent)

### getIndexOfChild

    public int getIndexOfChild(java.lang.Object parent,
                               java.lang.Object child)

### isCellEditable

    public boolean isCellEditable(java.lang.Object node,
                                  int column)

  Returns true if the cell for the `node` at `columnIndex` is editable. Otherwise, `setValueAt` on the cell will not change the value of that cell. The `node` must be managed by this model. Unamanaged nodes should throw an `IllegalArgumentException`.

  Specified by:
    `isCellEditable` in interface `TreeTableModel`
  Overrides:
    `isCellEditable` in class `AbstractTreeTableModel`
  Parameters:
    `node` - the node whose value to be queried
    `column` - the column whose value to be queried
  Returns:
    true if the cell is editable
  See Also:
    `TreeTableModel.setValueAt(java.lang.Object, java.lang.Object, int)`, `TableModel.isCellEditable(int, int)`

### isLeaf

    public boolean isLeaf(java.lang.Object node)

  Returns `true` if `node` is a leaf.

  Specified by:
    `isLeaf` in interface `javax.swing.tree.TreeModel`
  Overrides:
    `isLeaf` in class `AbstractTreeTableModel`
  Parameters:
    `node` - a node in the tree, obtained from this data source
  Returns:
    true if `node` is a leaf

### getPathToRoot

    public TreeTableNode[] getPathToRoot(TreeTableNode aNode)

  Gets the path from the root to the specified node.

  Parameters:
    `aNode` - the node to query
  Returns:
    an array of `TreeTableNode`s, where `arr[0].equals(getRoot())` and `arr[arr.length - 1].equals(aNode)`, or an empty array if the node is not found.
  Throws:
    `java.lang.NullPointerException` - if `aNode` is `null`

### setRoot

    public void setRoot(TreeTableNode root)

  Sets the root for this table model. If no column identifiers have been specified, this will rebuild the identifier list, using `root` as an examplar of the table.

  Parameters:
    `root` - the node to set as root

### insertNodeInto

    public void insertNodeInto(MutableTreeTableNode newChild,
                               MutableTreeTableNode 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(MutableTreeTableNode 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.

### valueForPathChanged

    public void valueForPathChanged(javax.swing.tree.TreePath path,
                                    java.lang.Object newValue)

  Called when value for the item identified by path has been changed. If newValue signifies a truly new value the model should post a `treeNodesChanged` event.

  This changes the object backing the `TreeTableNode` described by the path. This change does not alter a nodes children in any way. If you need to change structure of the node, use one of the provided mutator methods.

  Specified by:
    `valueForPathChanged` in interface `javax.swing.tree.TreeModel`
  Overrides:
    `valueForPathChanged` in class `AbstractTreeTableModel`
  Parameters:
    `path` - path to the node that has changed
    `newValue` - the new value
  Throws:
    `java.lang.NullPointerException` - if `path` is `null`
    `java.lang.IllegalArgumentException` - if `path` is not a path managed by this model
    `java.lang.ClassCastException` - if `path.getLastPathComponent()` is not a `TreeTableNode`

### setUserObject

    public void setUserObject(TreeTableNode node,
                              java.lang.Object userObject)

  Sets the user object for a node. Client code must use this method, so that the model can notify listeners that a change has occurred.

  This method is a convenient cover for `valueForPathChanged(TreePath, Object)`.

  Parameters:
    `node` - the node to modify
    `userObject` - the new user object to set
  Throws:
    `java.lang.NullPointerException` - if `node` is `null`
    `java.lang.IllegalArgumentException` - if `node` is not a node managed by this model

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2010. All Rights Reserved.