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
Class JXTable

    java.lang.Object
      java.awt.Component
          java.awt.Container
              javax.swing.JComponent
                  javax.swing.JTable
                      org.jdesktop.swingx.JXTable

All Implemented Interfaces:
  java.awt.image.ImageObserver, java.awt.MenuContainer, java.io.Serializable, java.util.EventListener, javax.accessibility.Accessible, javax.swing.event.CellEditorListener, javax.swing.event.ListSelectionListener, javax.swing.event.RowSorterListener, javax.swing.event.TableColumnModelListener, javax.swing.event.TableModelListener, javax.swing.Scrollable, TableColumnModelExtListener

Direct Known Subclasses:
  JXTreeTable

    public class JXTable

extends javax.swing.JTable
implements TableColumnModelExtListener

Enhanced Table component with support for general SwingX sorting/filtering, rendering, highlighting, rollover and search functionality. Table specific enhancements include runtime configuration options like toggle column visibility, column sizing, PENDING JW ...

## Sorting and Filtering

JXTable supports sorting and filtering of rows (switched to core sorting). Additionally, it provides api to apply a specific sort order, to toggle the sort order of columns identified by view index or column identifier and to reset all sorts. F.i:

     table.setSortOrder("PERSON_ID", SortOrder.DESCENDING);
     table.toggleSortOder(4);
     table.resetSortOrder();

Sorting sequence can be configured per column by setting the TableColumnExt's `comparator` property. Sorting can be disabled per column - setting the TableColumnExt's `sortable` or per table by `setSortable(boolean)`. The table takes responsibility to propagate these properties to the current sorter, if available

Note that the enhanced sorting controls are effective only if the RowSorter is of type SortController, which it is by default. Different from core JTable, the autoCreateRowSorter property is enabled by default. If on, the JXTable creates and uses a default row sorter as returned by the createDefaultRowSorter method.

Typically, a JXTable is sortable by left clicking on column headers. By default, each subsequent click on a header reverses the order of the sort, and a sort arrow icon is automatically drawn on the header.

## Rendering and Highlighting

As all SwingX collection views, a JXTable is a HighlighterClient (PENDING JW: formally define and implement, like in AbstractTestHighlighter), that is it provides consistent api to add and remove Highlighters which can visually decorate the rendering component.

An example multiple highlighting (default striping as appropriate for the current LookAndFeel, cell foreground on matching pattern, and shading a column):

     Highlighter simpleStriping = HighlighterFactory.createSimpleStriping();
     PatternPredicate patternPredicate = new PatternPredicate("ˆM", 1);
     ColorHighlighter magenta = new ColorHighlighter(patternPredicate, null,
           Color.MAGENTA, null, Color.MAGENTA);
     Highlighter shading = new ShadingColorHighlighter(
           new HighlightPredicate.ColumnHighlightPredicate(1));

     table.setHighlighters(simpleStriping,
            magenta,
            shading);

To fully support, JXTable registers SwingX default table renderers instead of core defaults (see `DefaultTableRenderer`) The recommended approach for customizing rendered content it to intall a DefaultTableRenderer configured with a custom String- and/or IconValue. F.i. assuming the cell value is a File and should be rendered by showing its name followed and date of last change:

     StringValue sv = new StringValue() {
          public String getString(Object value) {
            if (!(value instanceof File)) return StringValues.TO_STRING.getString(value);
            return StringValues.FILE_NAME.getString(value) + ", "
               + StringValues.DATE_TO_STRING.getString(((File) value).lastModified());
     }};
     table.setCellRenderer(File.class, new DefaultTableRenderer(sv));

Note: DefaultTableCellRenderer and subclasses require a hack to play nicely with Highlighters because it has an internal "color memory" in setForeground/setBackground. The hack is applied by default which might lead to unexpected side-effects in custom renderers subclassing DTCR. See `resetDefaultTableCellRendererHighlighter` for details.

Note: by default JXTable disables the alternate row striping provided by Nimbus, instead it does use the color provided by Nimbus to configure the UIColorHighlighter. Like in any other LAF without striping support, client code has to explicitly turn on striping by setting a Highlighter like:

     table.addHighlighter(HighlighterFactory.createSimpleStriping());

Alternatively, if client code wants to rely on the LAF provided striping support, it can set a property in the UIManager ("early" in the application lifetime to prevent JXTable to disable Nimbus handling it. In this case it is recommended to not any of the ui-dependent Highlighters provided by the HighlighterFactory.

     UIManager.put("Nimbus.keepAlternateRowColor", Boolean.TRUE);

## Rollover

As all SwingX collection views, a JXTable supports per-cell rollover which is enabled by default. If enabled, the component fires rollover events on enter/exit of a cell which by default is promoted to the renderer if it implements RolloverRenderer, that is simulates live behaviour. The rollover events can be used by client code as well, f.i. to decorate the rollover row using a Highlighter.

     JXTable table = new JXTable();
     table.addHighlighter(new ColorHighlighter(HighlightPredicate.ROLLOVER_ROW,
          null, Color.RED);

## Search

As all SwingX collection views, a JXTable is searchable. A search action is registered in its ActionMap under the key "find". The default behaviour is to ask the SearchFactory to open a search component on this component. The default keybinding is retrieved from the SearchFactory, typically ctrl-f (or cmd-f for Mac). Client code can register custom actions and/or bindings as appropriate.

JXTable provides api to vend a renderer-controlled String representation of cell content. This allows the Searchable and Highlighters to use WYSIWYM (What-You-See-Is-What-You-Match), that is pattern matching against the actual string as seen by the user.

## Column Configuration

JXTable's default column model is of type TableColumnModelExt which allows management of hidden columns. Furthermore, it guarantees to delegate creation and configuration of table columns to its ColumnFactory. The factory is meant as the central place to customize column configuration.

Columns can be hidden or shown by setting the visible property on the TableColumnExt using `TableColumnExt.setVisible(boolean)`. Columns can also be shown or hidden from the column control popup.

The column control popup is triggered by an icon drawn to the far right of the column headers, above the table's scrollbar (when installed in a JScrollPane). The popup allows the user to select which columns should be shown or hidden, as well as to pack columns and turn on horizontal scrolling. To show or hide the column control, use the `setColumnControlVisible(boolean show)`method.

You can resize all columns, selected columns, or a single column using the methods like `packAll()`. Packing combines several other aspects of a JXTable. If horizontal scrolling is enabled using `setHorizontalScrollEnabled(boolean)`, then the scrollpane will allow the table to scroll right-left, and columns will be sized to their preferred size. To control the preferred sizing of a column, you can provide a prototype value for the column in the TableColumnExt using `TableColumnExt.setPrototypeValue(Object)`. The prototype is used as an indicator of the preferred size of the column. This can be useful if some data in a given column is very long, but where the resize algorithm would normally not pick this up.

Keys/Actions registered with this component:

- "find" - open an appropriate search widget for searching cell content. The default action registeres itself with the SearchFactory as search target.
- "print" - print the table
- `HORIZONTALSCROLL_ACTION_COMMAND` - toggle the horizontal scrollbar
- `PACKSELECTED_ACTION_COMMAND` - resize the selected column to fit the widest cell content
- `PACKALL_ACTION_COMMAND` - resize all columns to fit the widest cell content in each column

Key bindings.

- "control F" - bound to actionKey "find".

Client Properties.

- `MATCH_HIGHLIGHTER` - set to Boolean.TRUE to use a SearchHighlighter to mark a cell as matching.

Author:
  Ramesh Gupta, Amy Fowler, Mark Davidson, Jeanette Winzenburg
See Also:
  Serialized Form

Nested Class Summary
`static class` | `JXTable.BooleanEditor` The default editor for `Boolean` types.
`static class` | `JXTable.GenericEditor` Default editor registered for `Object`.
`static class` | `JXTable.NumberEditor` Editor for `Number`s.
`protected static class` | `JXTable.TableAdapter`

Nested classes/interfaces inherited from class javax.swing.JTable
`javax.swing.JTable.AccessibleJTable, javax.swing.JTable.DropLocation, javax.swing.JTable.PrintMode`

Nested classes/interfaces inherited from class javax.swing.JComponent
`javax.swing.JComponent.AccessibleJComponent`

Nested classes/interfaces inherited from class java.awt.Container
`java.awt.Container.AccessibleAWTContainer`

Nested classes/interfaces inherited from class java.awt.Component
`java.awt.Component.AccessibleAWTComponent, java.awt.Component.BaselineResizeBehavior, java.awt.Component.BltBufferStrategy, java.awt.Component.FlipBufferStrategy`

Field Summary
`protected CompoundHighlighter` | `compoundHighlighter` The CompoundHighlighter for the table.
`protected ComponentAdapter` | `dataAdapter` The ComponentAdapter for model data access.
`protected org.jdesktop.swingx.JXTable.CellEditorRemover` | `editorRemover`
`protected boolean` | `filteredRowCountChanged` flag to indicate if a sortOrderChanged has happened between pre- and postProcessModelChange.
`static java.lang.String` | `FOCUS_NEXT_COMPONENT`
`static java.lang.String` | `FOCUS_PREVIOUS_COMPONENT`
`protected boolean` | `forceRevalidate` flag to indicate if forced revalidate is needed.
`static java.lang.String` | `HORIZONTALSCROLL_ACTION_COMMAND` Identifier of show horizontal scroll action, used in JXTable's `ActionMap`.
`protected boolean` | `isXTableRowHeightSet` Flag to distinguish internal settings of row height from client code settings.
`static java.lang.String` | `MATCH_HIGHLIGHTER` key for client property to use SearchHighlighter as match marker.
`static java.lang.String` | `PACKALL_ACTION_COMMAND` Identifier of pack table action, used in JXTable's `ActionMap` .
`static java.lang.String` | `PACKSELECTED_ACTION_COMMAND` Identifier of pack selected column action, used in JXTable's `ActionMap`.
`protected Highlighter` | `resetDefaultTableCellRendererHighlighter` The Highlighter used to hack around DefaultTableCellRenderer's color memory.
`protected Searchable` | `searchable` property to control search behaviour.
`static java.lang.String` | `UIPREFIX` The prefix marker to find table related properties in the `ResourceBundle`.
`static java.lang.String` | `USE_DTCR_COLORMEMORY_HACK` The key for the client property deciding about whether the color memory hack for DefaultTableCellRenderer should be used.

Fields inherited from class javax.swing.JTable
`AUTO_RESIZE_ALL_COLUMNS, AUTO_RESIZE_LAST_COLUMN, AUTO_RESIZE_NEXT_COLUMN, AUTO_RESIZE_OFF, AUTO_RESIZE_SUBSEQUENT_COLUMNS, autoCreateColumnsFromModel, autoResizeMode, cellEditor, cellSelectionEnabled, columnModel, dataModel, defaultEditorsByColumnClass, defaultRenderersByColumnClass, editingColumn, editingRow, editorComp, gridColor, preferredViewportSize, rowHeight, rowMargin, rowSelectionAllowed, selectionBackground, selectionForeground, selectionModel, showHorizontalLines, showVerticalLines, tableHeader`

Fields inherited from class javax.swing.JComponent
`accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW`

Fields inherited from class java.awt.Component
`BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT`

Fields inherited from interface java.awt.image.ImageObserver
`ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH`

Constructor Summary
`JXTable()` Instantiates a JXTable with a default table model, no data.
`JXTable(int numRows, int numColumns)` Instantiates a JXTable for a given number of columns and rows.
`JXTable(java.lang.Object[][] rowData, java.lang.Object[] columnNames)` Instantiates a JXTable with data in a array or rows and column names.
`JXTable(javax.swing.table.TableModel dm)` Instantiates a JXTable with a specific table model.
`JXTable(javax.swing.table.TableModel dm, javax.swing.table.TableColumnModel cm)` Instantiates a JXTable with a specific table model.
`JXTable(javax.swing.table.TableModel dm, javax.swing.table.TableColumnModel cm, javax.swing.ListSelectionModel sm)` Instantiates a JXTable with a specific table model, column model, and selection model.
`JXTable(java.util.Vector<?> rowData, java.util.Vector<?> columnNames)` Instantiates a JXTable with data in a vector or rows and column names.

Method Summary
`void` | `addHighlighter(Highlighter highlighter)` Appends a `Highlighter` to the end of the list of used `Highlighter`s.
`protected void` | `adjustComponentOrientation(java.awt.Component stamp)` Adjusts the `Component`'s orientation to this `JXTable`'s CO if appropriate.
`protected void` | `adminSetRowHeight(int rowHeight)` Sets the rowHeight for all rows to the given value.
`void` | `columnAdded(javax.swing.event.TableColumnModelEvent e)`
`void` | `columnMarginChanged(javax.swing.event.ChangeEvent e)`
`void` | `columnPropertyChange(java.beans.PropertyChangeEvent event)` Notifies listeners about property changes of contained columns.
`void` | `columnSelectionChanged(javax.swing.event.ListSelectionEvent e)`
`protected void` | `configureColumnControl()` Configures the upper trailing corner of an enclosing `JScrollPane`.
`protected void` | `configureEnclosingScrollPane()` Configures the enclosing `JScrollPane`.
`protected void` | `configureSorterProperties()` Propagates sort-related properties from table/columns to the sorter if it is of type SortController, does nothing otherwise.
`protected javax.swing.JComponent` | `createDefaultColumnControl()` Creates the default column control used by this table.
`protected javax.swing.table.TableColumnModel` | `createDefaultColumnModel()`
`void` | `createDefaultColumnsFromModel()` Creates, configures and adds default `TableColumn`s for columns in this table's `TableModel`.
`protected void` | `createDefaultEditors()` Creates default cell editors for objects, numbers, and boolean values.
`protected void` | `createDefaultRenderers()` Creates default cell renderers for `Object`s, `Number`s, `Date`s, `Boolean`s, and `Icon/Image/`s.
`protected javax.swing.RowSorter<? extends javax.swing.table.TableModel>` | `createDefaultRowSorter()` Creates and returns the default RowSorter.
`protected StringValueRegistry` | `createDefaultStringValueRegistry()` Creates and returns the default registry for StringValues.
`protected javax.swing.table.JTableHeader` | `createDefaultTableHeader()`
`protected javax.swing.event.ChangeListener` | `createHighlighterChangeListener()` Creates and returns the ChangeListener observing Highlighters.
`protected TableRolloverController<JXTable>` | `createLinkController()` Creates and returns a RolloverController appropriate for this component.
`protected RolloverProducer` | `createRolloverProducer()` Creates and returns the RolloverProducer to use with this component.
`protected void` | `doFind()` Starts a search on this List's visible items.
`void` | `doLayout()` Layouts column width.
`boolean` | `editCellAt(int row, int column, java.util.EventObject e)`
`boolean` | `getAutoCreateColumnsFromModel()`
`boolean` | `getAutoCreateRowSorter()`
`javax.swing.table.TableCellRenderer` | `getCellRenderer(int row, int column)`
`javax.swing.table.TableColumn` | `getColumn(int viewColumnIndex)` Returns the `TableColumn` at view position `columnIndex`.
`javax.swing.JComponent` | `getColumnControl()` Returns the component used as column control.
`int` | `getColumnCount(boolean includeHidden)` Returns the number of contained columns.
`TableColumnExt` | `getColumnExt(int viewColumnIndex)` Returns the `TableColumnExt` at view position `columnIndex`.
`TableColumnExt` | `getColumnExt(java.lang.Object identifier)` Returns the first `TableColumnExt` with the given `identifier`.
`ColumnFactory` | `getColumnFactory()` Returns the ColumnFactory.
`int` | `getColumnMargin()` Returns the margin between columns.
`java.util.List<javax.swing.table.TableColumn>` | `getColumns()` Returns a `List` of visible `TableColumn`s.
`java.util.List<javax.swing.table.TableColumn>` | `getColumns(boolean includeHidden)` Returns a `List` of contained `TableColumn`s.
`protected ComponentAdapter` | `getComponentAdapter()`
`protected ComponentAdapter` | `getComponentAdapter(int row, int column)` Convenience to access a configured ComponentAdapter.
`protected CompoundHighlighter` | `getCompoundHighlighter()` Returns the CompoundHighlighter assigned to the table, null if none.
`protected boolean` | `getControlsSorterProperties()` Returns a boolean indicating whether the table configures the sorter's properties.
`protected javax.swing.event.ChangeListener` | `getHighlighterChangeListener()` Returns the `ChangeListener` to use with highlighters.
`Highlighter[]` | `getHighlighters()` Returns the `Highlighter`s used by this table.
`protected TableRolloverController<JXTable>` | `getLinkController()` Returns the RolloverController for this component.
`javax.swing.table.TableCellRenderer` | `getNewDefaultRenderer(java.lang.Class<?> columnClass)` Deprecated. not working anyway - no replacement.
`java.awt.Dimension` | `getPreferredScrollableViewportSize()`
`javax.swing.RowFilter<?,?>` | `getRowFilter()` Returns the filter of the sorter, if available and of type SortController.
`boolean` | `getScrollableTracksViewportWidth()`
`Searchable` | `getSearchable()` Returns a Searchable for this component, guaranteed to be not null.
`int` | `getSelectionMode()` Returns the selection mode used by this table's selection model.
`protected SortController<? extends javax.swing.table.TableModel>` | `getSortController()` Returns the currently active SortController.
`javax.swing.table.TableColumn` | `getSortedColumn()` Returns the primary sort column, or null if nothing sorted or no sortKey corresponds to a TableColumn currently contained in the TableColumnModel.
`javax.swing.SortOrder` | `getSortOrder(int columnIndex)` Returns the SortOrder of the given column.
`javax.swing.SortOrder` | `getSortOrder(java.lang.Object identifier)` Returns the SortOrder of the given column.
`javax.swing.SortOrder[]` | `getSortOrderCycle()` Returns the sortOrder cycle used when toggle sorting this table's columns, guaranteed to be not null.
`boolean` | `getSortsOnUpdates()` Returns true if a sort should happen when the underlying model is updated; otherwise, returns false.
`java.lang.String` | `getStringAt(int row, int column)` Returns the string representation of the cell value at the given position.
`protected StringValueRegistry` | `getStringValueRegistry()` Returns the StringValueRegistry which defines the string representation for each cells.
`protected java.lang.String` | `getUIString(java.lang.String key)` Returns a potentially localized value from the UIManager.
`protected java.lang.String` | `getUIString(java.lang.String key, java.util.Locale locale)` Returns a potentially localized value from the UIManager for the given locale.
`int` | `getVisibleColumnCount()` Returns the preferred number of columns to show in the `JScrollPane`.
`int` | `getVisibleRowCount()` Returns the preferred number of rows to show in a `JScrollPane`.
`protected boolean` | `hasSortController()` Returns a boolean indicating whether the table has a SortController.
`protected void` | `initializeColumnPreferredWidth(javax.swing.table.TableColumn column)` Initialize the width related properties of the specified column.
`protected void` | `initializeColumnWidths()` Initialize the width related properties of all contained TableColumns, both visible and hidden.
`boolean` | `isAutoStartEditOnKeyStroke()` Returns the autoStartsEdit property.
`boolean` | `isCellEditable(int row, int column)` Returns true if the cell at `row` and `column` is editable.
`boolean` | `isColumnControlVisible()` Returns the column control visible property.
`protected boolean` | `isDataChanged(javax.swing.event.TableModelEvent e)` Convenience method to detect dataChanged table event type.
`boolean` | `isEditable()` Returns the editable property of the `JXTable` as a whole.
`boolean` | `isFocusCycleRoot()`
`boolean` | `isHorizontalScrollEnabled()` Returns the current setting for horizontal scrolling.
`boolean` | `isRolloverEnabled()` Returns a boolean indicating whether or not rollover support is enabled.
`boolean` | `isRowHeightEnabled()` Deprecated. no longer necessary (switched to 1.6)
`boolean` | `isSortable()` Returns the table's sortable property.
`protected boolean` | `isSortable(int columnIndex)` Deprecated.
`protected boolean` | `isSortable(java.lang.Object identifier)` Deprecated.
`protected boolean` | `isStructureChanged(javax.swing.event.TableModelEvent e)` Convenience method to detect a structureChanged table event type.
`boolean` | `isTerminateEditOnFocusLost()` Returns the property which determines the edit termination behaviour on focus lost.
`protected boolean` | `isUpdate(javax.swing.event.TableModelEvent e)` Convenience method to detect update table event type.
`void` | `packAll()` Resizes all columns to fit their content.
`void` | `packColumn(int column, int margin)` Packs an indivudal column in the table.
`void` | `packColumn(int column, int margin, int max)` Packs an indivual column in the table to less than or equal to the maximum witdth.
`void` | `packSelected()` Resizes the lead column to fit its content.
`void` | `packTable(int margin)` Packs all the columns to their optimal size.
`protected void` | `postprocessModelChange(javax.swing.event.TableModelEvent e)` Hack around core issue 6791934: forces a revalidate if appropriate and resets internal flags.
`protected void` | `postprocessSorterChanged(javax.swing.event.RowSorterEvent e)` Hack around core issue 6791934: sets the sorter changed flag if appropriate.
`java.awt.Component` | `prepareEditor(javax.swing.table.TableCellEditor editor, int row, int column)`
`java.awt.Component` | `prepareRenderer(javax.swing.table.TableCellRenderer renderer, int row, int column)` Returns the decorated `Component` used as a stamp to render the specified cell.
`protected void` | `preprocessModelChange(javax.swing.event.TableModelEvent e)` Hack around core issue 6791934: sets flags to force revalidate if appropriate.
`void` | `removeEditor()` Overridden with backport from Mustang fix for #4684090, #4887999.
`void` | `removeHighlighter(Highlighter highlighter)` Removes the given Highlighter.
`void` | `removeNotify()`
`protected void` | `resetDefaultTableCellRendererColors(java.awt.Component renderer, int row, int column)` Method to apply a hack around DefaultTableCellRenderer "color memory" (Issue #258-swingx).
`void` | `resetSortOrder()` Resets sorting of all columns.
`int` | `rowAtPoint(java.awt.Point point)`
`void` | `scrollCellToVisible(int row, int column)` Scrolls to make the cell at row and column visible.
`void` | `scrollColumnToVisible(int column)` Scrolls horizontally to make the given column visible.
`void` | `scrollRowToVisible(int row)` Scrolls vertically to make the given row visible.
`void` | `setAutoCreateRowSorter(boolean autoCreateRowSorter)`
`void` | `setAutoResizeMode(int mode)`
`void` | `setAutoStartEditOnKeyStroke(boolean autoStart)` Sets the autoStartsEdit property.
`void` | `setColumnControl(javax.swing.JComponent columnControl)` Sets the component used as column control.
`void` | `setColumnControlVisible(boolean visible)` Sets the column control visible property.
`void` | `setColumnFactory(ColumnFactory columnFactory)` Sets the `ColumnFactory` to use for column creation and configuration.
`void` | `setColumnMargin(int value)` Sets the margin between columns.
`void` | `setColumnModel(javax.swing.table.TableColumnModel columnModel)`
`void` | `setColumnSequence(java.lang.Object[] identifiers)` Reorders the columns in the sequence given array.
`void` | `setComponentOrientation(java.awt.ComponentOrientation o)` Sets the language-sensitive orientation that is to be used to order the elements or text within this component.
`void` | `setDefaultRenderer(java.lang.Class<?> columnClass, javax.swing.table.TableCellRenderer renderer)`
`void` | `setEditable(boolean editable)` Sets the editable property.
`void` | `setFillsViewportHeight(boolean fillsViewportHeight)`
`void` | `setGridColor(java.awt.Color gridColor)`
`void` | `setHighlighters(Highlighter... highlighters)` Sets the `Highlighter`s to the table, replacing any old settings.
`void` | `setHorizontalScrollEnabled(boolean enabled)` Sets the enablement of enhanced horizontal scrolling.
`void` | `setLocale(java.util.Locale locale)`
`void` | `setModel(javax.swing.table.TableModel dataModel)`
`void` | `setPreferredScrollableViewportSize(java.awt.Dimension size)`
`void` | `setRolloverEnabled(boolean rolloverEnabled)` Sets the property to enable/disable rollover support.
`void` | `setRowFilter(javax.swing.RowFilter<? super javax.swing.table.TableModel,? super java.lang.Integer> filter)` Sets the filter to the sorter, if available and of type SortController.
`void` | `setRowHeight(int rowHeight)`
`void` | `setRowHeightEnabled(boolean enabled)` Deprecated. no longer necessary (switched to 1.6)
`void` | `setRowSorter(javax.swing.RowSorter<? extends javax.swing.table.TableModel> sorter)`
`void` | `setSearchable(Searchable searchable)` Sets the Searchable for this table.
`void` | `setSelectionBackground(java.awt.Color selectionBackground)`
`void` | `setSelectionForeground(java.awt.Color selectionForeground)`
`void` | `setShowGrid(boolean showGrid)`
`void` | `setShowGrid(boolean showHorizontalLines, boolean showVerticalLines)` Convenience to set both grid line visibility and default margin for horizontal/vertical lines.
`void` | `setSortable(boolean sortable)` Sets "sortable" property indicating whether or not this table supports sortable columns.
`void` | `setSortOrder(int columnIndex, javax.swing.SortOrder sortOrder)` Sorts the table by the given column using SortOrder.
`void` | `setSortOrder(java.lang.Object identifier, javax.swing.SortOrder sortOrder)` Sorts the table by the given column using the SortOrder.
`void` | `setSortOrderCycle(javax.swing.SortOrder... cycle)` Sets the sortorder cycle used when toggle sorting this table's columns.
`void` | `setSortsOnUpdates(boolean sortsOnUpdates)` If true, specifies that a sort should happen when the underlying model is updated (`rowsUpdated` is invoked).
`void` | `setTerminateEditOnFocusLost(boolean terminate)` Sets the property to determine whether an ongoing edit should be terminated if the focus is moved to somewhere outside of the table.
`void` | `setValueAt(java.lang.Object aValue, int row, int column)` Overridden to account for row index mapping.
`void` | `setVisibleColumnCount(int visibleColumnCount)` Sets the preferred number of Columns to show in a `JScrollPane`.
`void` | `setVisibleRowCount(int visibleRowCount)` Sets the preferred number of rows to show in a `JScrollPane`.
`void` | `sorterChanged(javax.swing.event.RowSorterEvent e)` Overridden to hack around core bug http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6791934
`void` | `tableChanged(javax.swing.event.TableModelEvent e)`
`void` | `toggleSortOrder(int columnIndex)` Toggles the sort order of the column at columnIndex.
`void` | `toggleSortOrder(java.lang.Object identifier)` Toggles the sort order of the column with identifier.
`void` | `transferFocus()`
`void` | `transferFocusBackward()`
`protected void` | `unconfigureColumnControl()` /** Unconfigures the upper trailing corner of an enclosing `JScrollPane`.
`protected void` | `unconfigureEnclosingScrollPane()` Unconfigures the enclosing `JScrollPane`.
`protected void` | `updateColumnControlUI()` Updates the ui of the columnControl if appropriate.
`protected void` | `updateColumnUI(javax.swing.table.TableColumn column)` Updates TableColumn after updateUI changes.
`protected void` | `updateHighlighterUI()` Updates highlighter after `updateUI` changes.
`protected void` | `updateHorizontalAction()` Synchs selected state of horizontal scrolling `Action` to enablement of enhanced auto-resize behaviour.
`protected void` | `updateLocaleActionState(java.lang.String key, java.util.Locale locale)` Updates locale-dependent state of action registered with key in `ActionMap`.
`protected void` | `updateLocaleState(java.util.Locale locale)` Updates locale-dependent state to the given `Locale`.
`protected void` | `updateRowHeightUI(boolean respectRowSetFlag)` Auto-adjusts rowHeight to something more pleasing then the default.
`void` | `updateUI()`

Methods inherited from class javax.swing.JTable
`addColumn, addColumnSelectionInterval, addNotify, addRowSelectionInterval, changeSelection, clearSelection, columnAtPoint, columnMoved, columnRemoved, convertColumnIndexToModel, convertColumnIndexToView, convertRowIndexToModel, convertRowIndexToView, createDefaultDataModel, createDefaultSelectionModel, createScrollPaneForTable, editCellAt, editingCanceled, editingStopped, getAccessibleContext, getAutoResizeMode, getCellEditor, getCellEditor, getCellRect, getCellSelectionEnabled, getColumn, getColumnClass, getColumnCount, getColumnModel, getColumnName, getColumnSelectionAllowed, getDefaultEditor, getDefaultRenderer, getDragEnabled, getDropLocation, getDropMode, getEditingColumn, getEditingRow, getEditorComponent, getFillsViewportHeight, getGridColor, getIntercellSpacing, getModel, getPrintable, getRowCount, getRowHeight, getRowHeight, getRowMargin, getRowSelectionAllowed, getRowSorter, getScrollableBlockIncrement, getScrollableTracksViewportHeight, getScrollableUnitIncrement, getSelectedColumn, getSelectedColumnCount, getSelectedColumns, getSelectedRow, getSelectedRowCount, getSelectedRows, getSelectionBackground, getSelectionForeground, getSelectionModel, getShowHorizontalLines, getShowVerticalLines, getSurrendersFocusOnKeystroke, getTableHeader, getToolTipText, getUI, getUIClassID, getUpdateSelectionOnSort, getValueAt, initializeLocalVars, isCellSelected, isColumnSelected, isEditing, isRowSelected, moveColumn, paramString, print, print, print, print, print, processKeyBinding, removeColumn, removeColumnSelectionInterval, removeRowSelectionInterval, resizeAndRepaint, selectAll, setAutoCreateColumnsFromModel, setCellEditor, setCellSelectionEnabled, setColumnSelectionAllowed, setColumnSelectionInterval, setDefaultEditor, setDragEnabled, setDropMode, setEditingColumn, setEditingRow, setIntercellSpacing, setRowHeight, setRowMargin, setRowSelectionAllowed, setRowSelectionInterval, setSelectionMode, setSelectionModel, setShowHorizontalLines, setShowVerticalLines, setSurrendersFocusOnKeystroke, setTableHeader, setUI, setUpdateSelectionOnSort, sizeColumnsToFit, sizeColumnsToFit, valueChanged`

Methods inherited from class javax.swing.JComponent
`addAncestorListener, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, disable, enable, firePropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, getActionForKeyStroke, getActionMap, getAlignmentX, getAlignmentY, getAncestorListeners, getAutoscrolls, getBaseline, getBaselineResizeBehavior, getBorder, getBounds, getClientProperty, getComponentGraphics, getComponentPopupMenu, getConditionForKeyStroke, getDebugGraphicsOptions, getDefaultLocale, getFontMetrics, getGraphics, getHeight, getInheritsPopupMenu, getInputMap, getInputMap, getInputVerifier, getInsets, getInsets, getListeners, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPopupLocation, getPreferredSize, getRegisteredKeyStrokes, getRootPane, getSize, getToolTipLocation, getToolTipText, getTopLevelAncestor, getTransferHandler, getVerifyInputWhenFocusTarget, getVetoableChangeListeners, getVisibleRect, getWidth, getX, getY, grabFocus, isDoubleBuffered, isLightweightComponent, isManagingFocus, isOpaque, isOptimizedDrawingEnabled, isPaintingForPrint, isPaintingTile, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintComponent, paintImmediately, paintImmediately, print, printAll, printBorder, printChildren, printComponent, processComponentKeyEvent, processKeyEvent, processMouseEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, resetKeyboardActions, reshape, revalidate, scrollRectToVisible, setActionMap, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setComponentPopupMenu, setDebugGraphicsOptions, setDefaultLocale, setDoubleBuffered, setEnabled, setFocusTraversalKeys, setFont, setForeground, setInheritsPopupMenu, setInputMap, setInputVerifier, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setTransferHandler, setUI, setVerifyInputWhenFocusTarget, setVisible, unregisterKeyboardAction, update`

Methods inherited from class java.awt.Container
`add, add, add, add, add, addContainerListener, addImpl, addPropertyChangeListener, addPropertyChangeListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, findComponentAt, findComponentAt, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getComponentZOrder, getContainerListeners, getFocusTraversalKeys, getFocusTraversalPolicy, getLayout, getMousePosition, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusTraversalPolicyProvider, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paintComponents, preferredSize, printComponents, processContainerEvent, processEvent, remove, remove, removeAll, removeContainerListener, setComponentZOrder, setFocusCycleRoot, setFocusTraversalPolicy, setFocusTraversalPolicyProvider, setLayout, transferFocusDownCycle, validate, validateTree`

Methods inherited from class java.awt.Component
`action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, createImage, createImage, createVolatileImage, createVolatileImage, disableEvents, dispatchEvent, enable, enableEvents, enableInputMethods, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, getBackground, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusCycleRootAncestor, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getForeground, getGraphicsConfiguration, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputContext, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocale, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMousePosition, getMouseWheelListeners, getName, getParent, getPeer, getPropertyChangeListeners, getPropertyChangeListeners, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hasFocus, hide, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isMaximumSizeSet, isMinimumSizeSet, isPreferredSizeSet, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, removePropertyChangeListener, removePropertyChangeListener, repaint, repaint, repaint, resize, resize, setBounds, setBounds, setCursor, setDropTarget, setFocusable, setFocusTraversalKeysEnabled, setIgnoreRepaint, setLocation, setLocation, setName, setSize, setSize, show, show, size, toString, transferFocusUpCycle`

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

Methods inherited from interface javax.swing.event.TableColumnModelListener
`columnMoved, columnRemoved`

Field Detail

### FOCUS_PREVIOUS_COMPONENT

    public static final java.lang.String FOCUS_PREVIOUS_COMPONENT

See Also:
  Constant Field Values

### FOCUS_NEXT_COMPONENT

    public static final java.lang.String FOCUS_NEXT_COMPONENT

See Also:
  Constant Field Values

### HORIZONTALSCROLL_ACTION_COMMAND

    public static final java.lang.String HORIZONTALSCROLL_ACTION_COMMAND

  Identifier of show horizontal scroll action, used in JXTable's `ActionMap`.

  See Also:
    Constant Field Values

### PACKALL_ACTION_COMMAND

    public static final java.lang.String PACKALL_ACTION_COMMAND

  Identifier of pack table action, used in JXTable's `ActionMap` .

  See Also:
    Constant Field Values

### PACKSELECTED_ACTION_COMMAND

    public static final java.lang.String PACKSELECTED_ACTION_COMMAND

  Identifier of pack selected column action, used in JXTable's `ActionMap`.

  See Also:
    Constant Field Values

### UIPREFIX

    public static final java.lang.String UIPREFIX

  The prefix marker to find table related properties in the `ResourceBundle`.

  See Also:
    Constant Field Values

### MATCH_HIGHLIGHTER

    public static final java.lang.String MATCH_HIGHLIGHTER

  key for client property to use SearchHighlighter as match marker.

  See Also:
    Constant Field Values

### compoundHighlighter

    protected CompoundHighlighter compoundHighlighter

  The CompoundHighlighter for the table.

### USE_DTCR_COLORMEMORY_HACK

    public static final java.lang.String USE_DTCR_COLORMEMORY_HACK

  The key for the client property deciding about whether the color memory hack for DefaultTableCellRenderer should be used.

  See Also:
    `resetDefaultTableCellRendererHighlighter`, Constant Field Values

### resetDefaultTableCellRendererHighlighter

    protected Highlighter resetDefaultTableCellRendererHighlighter

  The Highlighter used to hack around DefaultTableCellRenderer's color memory.

### dataAdapter

    protected ComponentAdapter dataAdapter

  The ComponentAdapter for model data access.

### isXTableRowHeightSet

    protected boolean isXTableRowHeightSet

  Flag to distinguish internal settings of row height from client code settings. The rowHeight will be internally adjusted to font size on instantiation and in updateUI if the height has not been set explicitly by the application.

  See Also:
    `adminSetRowHeight(int)`, `setRowHeight(int)`

### searchable

    protected Searchable searchable

  property to control search behaviour.

### forceRevalidate

    protected boolean forceRevalidate

  flag to indicate if forced revalidate is needed.

### filteredRowCountChanged

    protected boolean filteredRowCountChanged

  flag to indicate if a sortOrderChanged has happened between pre- and postProcessModelChange.

### editorRemover

    protected transient org.jdesktop.swingx.JXTable.CellEditorRemover editorRemover

Constructor Detail

### JXTable

    public JXTable()

  Instantiates a JXTable with a default table model, no data.

### JXTable

    public JXTable(javax.swing.table.TableModel dm)

  Instantiates a JXTable with a specific table model.

  Parameters:
    `dm` - The model to use.

### JXTable

    public JXTable(javax.swing.table.TableModel dm,
                   javax.swing.table.TableColumnModel cm)

  Instantiates a JXTable with a specific table model.

  Parameters:
    `dm` - The model to use.

### JXTable

    public JXTable(javax.swing.table.TableModel dm,
                   javax.swing.table.TableColumnModel cm,
                   javax.swing.ListSelectionModel sm)

  Instantiates a JXTable with a specific table model, column model, and selection model.

  Parameters:
    `dm` - The table model to use.
    `cm` - The column model to use.
    `sm` - The list selection model to use.

### JXTable

    public JXTable(int numRows,
                   int numColumns)

  Instantiates a JXTable for a given number of columns and rows.

  Parameters:
    `numRows` - Count of rows to accommodate.
    `numColumns` - Count of columns to accommodate.

### JXTable

    public JXTable(java.util.Vector<?> rowData,
                   java.util.Vector<?> columnNames)

  Instantiates a JXTable with data in a vector or rows and column names.

  Parameters:
    `rowData` - Row data, as a Vector of Objects.
    `columnNames` - Column names, as a Vector of Strings.

### JXTable

    public JXTable(java.lang.Object[][] rowData,
                   java.lang.Object[] columnNames)

  Instantiates a JXTable with data in a array or rows and column names.

  Parameters:
    `rowData` - Row data, as a two-dimensional Array of Objects (by row, for column).
    `columnNames` - Column names, as a Array of Strings.

Method Detail

### setRolloverEnabled

    public void setRolloverEnabled(boolean rolloverEnabled)

  Sets the property to enable/disable rollover support. If enabled, this component fires property changes on per-cell mouse rollover state, i.e. when the mouse enters/leaves a list cell.

  This can be enabled to show "live" rollover behaviour, f.i. the cursor over a cell rendered by a JXHyperlink.

  The default value is true.

  Parameters:
    `rolloverEnabled` - a boolean indicating whether or not the rollover functionality should be enabled.
  See Also:
    `isRolloverEnabled()`, `getLinkController()`, `createRolloverProducer()`, `RolloverRenderer`

### isRolloverEnabled

    public boolean isRolloverEnabled()

  Returns a boolean indicating whether or not rollover support is enabled.

  Returns:
    a boolean indicating whether or not rollover support is enabled.
  See Also:
    `setRolloverEnabled(boolean)`

### getLinkController

    protected TableRolloverController<JXTable> getLinkController()

  Returns the RolloverController for this component. Lazyly creates the controller if necessary, that is the return value is guaranteed to be not null.

  PENDING JW: rename to getRolloverController

  Returns:
    the RolloverController for this tree, guaranteed to be not null.
  See Also:
    `setRolloverEnabled(boolean)`, `createLinkController()`, `RolloverController`

### createLinkController

    protected TableRolloverController<JXTable> createLinkController()

  Creates and returns a RolloverController appropriate for this component.

  Returns:
    a RolloverController appropriate for this component.
  See Also:
    `getLinkController()`, `RolloverController`

### createRolloverProducer

    protected RolloverProducer createRolloverProducer()

  Creates and returns the RolloverProducer to use with this component.

  Returns:
    `RolloverProducer` to use with this component
  See Also:
    `setRolloverEnabled(boolean)`

### isColumnControlVisible

    public boolean isColumnControlVisible()

  Returns the column control visible property.

  Returns:
    boolean to indicate whether the column control is visible.
  See Also:
    `setColumnControlVisible(boolean)`, `setColumnControl(JComponent)`

### setColumnControlVisible

    public void setColumnControlVisible(boolean visible)

  Sets the column control visible property. If true and `JXTable` is contained in a `JScrollPane`, the table adds the column control to the trailing corner of the scroll pane.

  Note: if the table is not inside a `JScrollPane` the column control is not shown even if this returns true. In this case it's the responsibility of the client code to actually show it.

  The default value is `false`.

  Parameters:
    `visible` - boolean to indicate if the column control should be shown
  See Also:
    `isColumnControlVisible()`, `setColumnControl(JComponent)`

### getColumnControl

    public javax.swing.JComponent getColumnControl()

  Returns the component used as column control. Lazily creates the control to the default if it is `null`.

  Returns:
    component for column control, guaranteed to be != null.
  See Also:
    `setColumnControl(JComponent)`, `createDefaultColumnControl()`

### setColumnControl

    public void setColumnControl(javax.swing.JComponent columnControl)

  Sets the component used as column control. Updates the enclosing `JScrollPane` if appropriate. Passing a `null` parameter restores the column control to the default.

  The component is automatically visible only if the `columnControlVisible` property is `true` and the table is contained in a `JScrollPane`.

  NOTE: from the table's perspective, the column control is simply a `JComponent` to add to and keep in the trailing corner of the scrollpane. (if any). It's up the concrete control to configure itself from and keep synchronized to the columns' states.

  Parameters:
    `columnControl` - the `JComponent` to use as columnControl.
  See Also:
    `getColumnControl()`, `createDefaultColumnControl()`, `setColumnControlVisible(boolean)`

### createDefaultColumnControl

    protected javax.swing.JComponent createDefaultColumnControl()

  Creates the default column control used by this table. This implementation returns a `ColumnControlButton` configured with default `ColumnControlIcon`.

  Returns:
    the default component used as column control.
  See Also:
    `setColumnControl(JComponent)`, `ColumnControlButton`, `ColumnControlIcon`

### setComponentOrientation

    public void setComponentOrientation(java.awt.ComponentOrientation o)

  Sets the language-sensitive orientation that is to be used to order the elements or text within this component.

  Overridden to work around a core bug: `JScrollPane` can't cope with corners when changing component orientation at runtime. This method explicitly re-configures the column control.

  Overrides:
    `setComponentOrientation` in class `java.awt.Component`
  Parameters:
    `o` - the ComponentOrientation for this table.
  See Also:
    `Component.setComponentOrientation(ComponentOrientation)`

### configureEnclosingScrollPane

    protected void configureEnclosingScrollPane()

  Configures the enclosing `JScrollPane`.

  Overridden to addionally configure the upper trailing corner with the column control.

  Overrides:
    `configureEnclosingScrollPane` in class `javax.swing.JTable`
  See Also:
    `configureColumnControl()`

### unconfigureEnclosingScrollPane

    protected void unconfigureEnclosingScrollPane()

  Unconfigures the enclosing `JScrollPane`.

  Overridden to addionally unconfigure the upper trailing corner with the column control.

  Overrides:
    `unconfigureEnclosingScrollPane` in class `javax.swing.JTable`
  See Also:
    `unconfigureColumnControl()`

### unconfigureColumnControl

    protected void unconfigureColumnControl()

  /** Unconfigures the upper trailing corner of an enclosing `JScrollPane`. Here: removes the upper trailing corner and resets.

  See Also:
    `setColumnControlVisible(boolean)`, `setColumnControl(JComponent)`

### configureColumnControl

    protected void configureColumnControl()

  Configures the upper trailing corner of an enclosing `JScrollPane`. Adds the `ColumnControl` if the `columnControlVisible` property is true.

  See Also:
    `setColumnControlVisible(boolean)`, `setColumnControl(JComponent)`

### getUIString

    protected java.lang.String getUIString(java.lang.String key)

  Returns a potentially localized value from the UIManager. The given key is prefixed by this table's `UIPREFIX` before doing the lookup. The lookup respects this table's current `locale` property. Returns the key, if no value is found.

  Parameters:
    `key` - the bare key to look up in the UIManager.
  Returns:
    the value mapped to UIPREFIX + key or key if no value is found.

### getUIString

    protected java.lang.String getUIString(java.lang.String key,
                                           java.util.Locale locale)

  Returns a potentially localized value from the UIManager for the given locale. The given key is prefixed by this table's `UIPREFIX` before doing the lookup. Returns the key, if no value is found.

  Parameters:
    `key` - the bare key to look up in the UIManager.
    `locale` - the locale use for lookup
  Returns:
    the value mapped to UIPREFIX + key in the given locale, or key if no value is found.

### setLocale

    public void setLocale(java.util.Locale locale)

  Overridden to update locale-dependent properties.

  Overrides:
    `setLocale` in class `java.awt.Component`
  See Also:
    `updateLocaleState(Locale)`

### updateLocaleState

    protected void updateLocaleState(java.util.Locale locale)

  Updates locale-dependent state to the given `Locale`. Here: updates registered column actions' locale-dependent state.

  PENDING: Try better to find all column actions including custom additions? Or move to columnControl?

  Parameters:
    `locale` - the Locale to use for value lookup
  See Also:
    `setLocale(Locale)`, `updateLocaleActionState(String, Locale)`

### updateLocaleActionState

    protected void updateLocaleActionState(java.lang.String key,
                                           java.util.Locale locale)

  Updates locale-dependent state of action registered with key in `ActionMap`. Does nothing if no action with key is found.

  Here: updates the `Action`'s name property.

  Parameters:
    `key` - the string for lookup in this table's ActionMap
  See Also:
    `updateLocaleState(Locale)`

### packAll

    public void packAll()

  Resizes all columns to fit their content.

  By default this method is bound to the pack all columns `Action` and registered in the table's `ActionMap`.

### packSelected

    public void packSelected()

  Resizes the lead column to fit its content.

  By default this method is bound to the pack selected column `Action` and registered in the table's `ActionMap`.

### columnSelectionChanged

    public void columnSelectionChanged(javax.swing.event.ListSelectionEvent e)

  Overridden to update the enabled state of the pack selected column `Action`.

  Specified by:
    `columnSelectionChanged` in interface `javax.swing.event.TableColumnModelListener`
  Overrides:
    `columnSelectionChanged` in class `javax.swing.JTable`

### setHorizontalScrollEnabled

    public void setHorizontalScrollEnabled(boolean enabled)

  Sets the enablement of enhanced horizontal scrolling. If enabled, it toggles an auto-resize mode which always fills the `JViewport` horizontally and shows the horizontal scrollbar if necessary.

  The default value is `false`.

  Note: this is not a bound property, though it follows bean naming conventions. PENDING: Probably should be... If so, could be taken by a listening Action as in the app-framework.

  PENDING JW: the name is mis-leading?

  Parameters:
    `enabled` - a boolean indicating whether enhanced auto-resize mode is enabled.
  See Also:
    `isHorizontalScrollEnabled()`

### isHorizontalScrollEnabled

    public boolean isHorizontalScrollEnabled()

  Returns the current setting for horizontal scrolling.

  Returns:
    the enablement of enhanced horizontal scrolling.
  See Also:
    `setHorizontalScrollEnabled(boolean)`

### setAutoResizeMode

    public void setAutoResizeMode(int mode)

  Overridden for internal bookkeeping related to the enhanced auto-resize behaviour.

  Note: to enable/disable the enhanced auto-resize mode use exclusively `setHorizontalScrollEnabled`, this method can't cope with it.

  Overrides:
    `setAutoResizeMode` in class `javax.swing.JTable`
  See Also:
    `setHorizontalScrollEnabled(boolean)`

### updateHorizontalAction

    protected void updateHorizontalAction()

  Synchs selected state of horizontal scrolling `Action` to enablement of enhanced auto-resize behaviour.

### getScrollableTracksViewportWidth

    public boolean getScrollableTracksViewportWidth()

  Overridden to support enhanced auto-resize behaviour enabled and necessary.

  Specified by:
    `getScrollableTracksViewportWidth` in interface `javax.swing.Scrollable`
  Overrides:
    `getScrollableTracksViewportWidth` in class `javax.swing.JTable`
  See Also:
    `setHorizontalScrollEnabled(boolean)`

### doLayout

    public void doLayout()

  Layouts column width. The exact behaviour depends on the `autoResizeMode` property.

  Overridden to support enhanced auto-resize behaviour enabled and necessary.

  Overrides:
    `doLayout` in class `javax.swing.JTable`
  See Also:
    `setAutoResizeMode(int)`, `setHorizontalScrollEnabled(boolean)`

### columnMarginChanged

    public void columnMarginChanged(javax.swing.event.ChangeEvent e)

  Overridden to support enhanced auto-resize behaviour enabled and necessary.

  Specified by:
    `columnMarginChanged` in interface `javax.swing.event.TableColumnModelListener`
  Overrides:
    `columnMarginChanged` in class `javax.swing.JTable`
  See Also:
    `setHorizontalScrollEnabled(boolean)`

### setFillsViewportHeight

    public void setFillsViewportHeight(boolean fillsViewportHeight)

  Overridden for documentation reasons only: same behaviour but different default value.

  The default value is `true`.

  Overrides:
    `setFillsViewportHeight` in class `javax.swing.JTable`

### setValueAt

    public void setValueAt(java.lang.Object aValue,
                           int row,
                           int column)

  Overridden to account for row index mapping. This implementation respects the cell's editability, that is it has no effect if `!isCellEditable(row, column)`.

  Overrides:
    `setValueAt` in class `javax.swing.JTable`
  See Also:
    `isCellEditable(int, int)`

### isCellEditable

    public boolean isCellEditable(int row,
                                  int column)

  Returns true if the cell at `row` and `column` is editable. Otherwise, invoking `setValueAt` on the cell will have no effect.

  Overridden to account for row index mapping and to support a layered editability control:

  - per-table: `JXTable.isEditable()`
  - per-column: `TableColumnExt.isEditable()`
  - per-cell: controlled by the model `TableModel.isCellEditable()`
  The view cell is considered editable only if all three layers are enabled.

  Overrides:
    `isCellEditable` in class `javax.swing.JTable`
  Parameters:
    `row` - the row index in view coordinates
    `column` - the column index in view coordinates
  Returns:
    true if the cell is editable
  See Also:
    `setValueAt(Object, int, int)`, `isEditable()`, `TableColumnExt.isEditable()`, `TableModel.isCellEditable(int, int)`

### getAutoCreateColumnsFromModel

    public boolean getAutoCreateColumnsFromModel()

  Overridden for documentation clarification. The property has the same meaning as super, that is if true to re-create all table columns on either setting a new TableModel or receiving a structureChanged from the existing. The most obvious visual effect is that custom column properties appear to be "lost".

  JXTable does support additonal custom configuration (via a custom ColumnFactory) which can (and incorrectly was) called independently from the creation. Setting this property to false guarantees that no column configuration is applied.

  Overrides:
    `getAutoCreateColumnsFromModel` in class `javax.swing.JTable`
  See Also:
    `tableChanged(TableModelEvent)`, `ColumnFactory`

### tableChanged

    public void tableChanged(javax.swing.event.TableModelEvent e)

  Overridden to update internal state related to enhanced functionality and hack around core bugs.

  - re-calculate intialize column width and preferred scrollable size after a structureChanged if autocreateColumnsFromModel is true.
  - update string representation control after structureChanged
  - core bug #6791934 logic to force revalidate if appropriate

  Specified by:
    `tableChanged` in interface `javax.swing.event.TableModelListener`
  Overrides:
    `tableChanged` in class `javax.swing.JTable`

### sorterChanged

    public void sorterChanged(javax.swing.event.RowSorterEvent e)

  Overridden to hack around core bug http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6791934

  Specified by:
    `sorterChanged` in interface `javax.swing.event.RowSorterListener`
  Overrides:
    `sorterChanged` in class `javax.swing.JTable`

### preprocessModelChange

    protected void preprocessModelChange(javax.swing.event.TableModelEvent e)

  Hack around core issue 6791934: sets flags to force revalidate if appropriate. Called before processing the event.

  Parameters:
    `e` - the TableModelEvent received from the model

### postprocessModelChange

    protected void postprocessModelChange(javax.swing.event.TableModelEvent e)

  Hack around core issue 6791934: forces a revalidate if appropriate and resets internal flags. Called after processing the event.

  Parameters:
    `e` - the TableModelEvent received from the model

### postprocessSorterChanged

    protected void postprocessSorterChanged(javax.swing.event.RowSorterEvent e)

  Hack around core issue 6791934: sets the sorter changed flag if appropriate. Called after processing the event.

  Parameters:
    `e` - the sorter event received from the sorter

### setModel

    public void setModel(javax.swing.table.TableModel dataModel)

  Overridden to prevent super from creating RowSorter.

  Overrides:
    `setModel` in class `javax.swing.JTable`

### setColumnModel

    public void setColumnModel(javax.swing.table.TableColumnModel columnModel)

  Overridden to synch sorter state from columns.

  Overrides:
    `setColumnModel` in class `javax.swing.JTable`

### setAutoCreateRowSorter

    public void setAutoCreateRowSorter(boolean autoCreateRowSorter)

  Overridden to

  - fix core bug: replaces sorter even if flag doesn't change.
  - use xflag (need because super's RowSorter creation is hard-coded.

  Overrides:
    `setAutoCreateRowSorter` in class `javax.swing.JTable`

### getAutoCreateRowSorter

    public boolean getAutoCreateRowSorter()

  Overridden to return xflag

  Overrides:
    `getAutoCreateRowSorter` in class `javax.swing.JTable`

### setRowSorter

    public void setRowSorter(javax.swing.RowSorter<? extends javax.swing.table.TableModel> sorter)

  Overridden propagate sort-related properties to the sorter after calling super, if the given RowSorter is of type SortController. Does nothing additional otherwise.

  Overrides:
    `setRowSorter` in class `javax.swing.JTable`

### configureSorterProperties

    protected void configureSorterProperties()

  Propagates sort-related properties from table/columns to the sorter if it is of type SortController, does nothing otherwise.

### createDefaultRowSorter

    protected javax.swing.RowSorter<? extends javax.swing.table.TableModel> createDefaultRowSorter()

  Creates and returns the default RowSorter. Note that this is already configured to the current TableModel - no api in the base class to set the model?

  PENDING JW: review method signature - better expose the need for the model by adding a parameter?

  Returns:
    the default RowSorter.

### isDataChanged

    protected boolean isDataChanged(javax.swing.event.TableModelEvent e)

  Convenience method to detect dataChanged table event type.

  Parameters:
    `e` - the event to examine.
  Returns:
    true if the event is of type dataChanged, false else.

### isUpdate

    protected boolean isUpdate(javax.swing.event.TableModelEvent e)

  Convenience method to detect update table event type.

  Parameters:
    `e` - the event to examine.
  Returns:
    true if the event is of type update and not dataChanged, false else.

### isStructureChanged

    protected boolean isStructureChanged(javax.swing.event.TableModelEvent e)

  Convenience method to detect a structureChanged table event type.

  Parameters:
    `e` - the event to examine.
  Returns:
    true if the event is of type structureChanged or null, false else.

### setSortable

    public void setSortable(boolean sortable)

  Sets "sortable" property indicating whether or not this table supports sortable columns. If `sortable` is `true` then sorting will be enabled on all columns whose `sortable` property is `true`. If `sortable` is `false` then sorting will be disabled for all columns, regardless of each column's individual `sorting` property. The default is `true`.

  Note: as of post-1.0 this property is propagated to the SortController if controlsSorterProperties is true. Whether or not a change triggers a re-sort is up to either the concrete controller implementation (the default doesn't) or client code. This behaviour is different from old SwingX style sorting.

  Parameters:
    `sortable` - boolean indicating whether or not this table supports sortable columns
  See Also:
    `getControlsSorterProperties()`

### isSortable

    public boolean isSortable()

  Returns the table's sortable property.

  Returns:
    true if the table is sortable.
  See Also:
    `setSortable(boolean)`

### setSortsOnUpdates

    public void setSortsOnUpdates(boolean sortsOnUpdates)

  If true, specifies that a sort should happen when the underlying model is updated (`rowsUpdated` is invoked). For example, if this is true and the user edits an entry the location of that item in the view may change. This property is propagated to the SortController if controlsSorterProperties is true.

  The default value is true.

  Parameters:
    `sortsOnUpdates` - whether or not to sort on update events
  See Also:
    `getSortsOnUpdates()`, `getControlsSorterProperties()`

### getSortsOnUpdates

    public boolean getSortsOnUpdates()

  Returns true if a sort should happen when the underlying model is updated; otherwise, returns false.

  Returns:
    whether or not to sort when the model is updated

### setSortOrderCycle

    public void setSortOrderCycle(javax.swing.SortOrder... cycle)

  Sets the sortorder cycle used when toggle sorting this table's columns. This property is propagated to the SortController if controlsSorterProperties is true.

  Parameters:
    `cycle` - the sequence of zero or more not-null SortOrders to cycle through.
  Throws:
    `java.lang.NullPointerException` - if the array or any of its elements are null

### getSortOrderCycle

    public javax.swing.SortOrder[] getSortOrderCycle()

  Returns the sortOrder cycle used when toggle sorting this table's columns, guaranteed to be not null.

  Returns:
    the sort order cycle used in toggle sort, not null

### setRowFilter

    public void setRowFilter(javax.swing.RowFilter<? super javax.swing.table.TableModel,? super java.lang.Integer> filter)

  Sets the filter to the sorter, if available and of type SortController. Does nothing otherwise.

  Parameters:
    `filter` - the filter used to determine what entries should be included

### getRowFilter

    public javax.swing.RowFilter<?,?> getRowFilter()

  Returns the filter of the sorter, if available and of type SortController. Returns null otherwise.

  PENDING JW: generics? had to remove return type from getSortController to make this compilable, so probably wrong.

  Returns:
    the filter used in the sorter.

### resetSortOrder

    public void resetSortOrder()

  Resets sorting of all columns. Delegates to the SortController if available, or does nothing if not.

  PENDING JW: method name - consistent in SortController and here.

### toggleSortOrder

    public void toggleSortOrder(int columnIndex)

  Toggles the sort order of the column at columnIndex. Delegates to the SortController if available, or does nothing if not.

  The exact behaviour is defined by the SortController's toggleSortOrder implementation. Typically a unsorted column is sorted in ascending order, a sorted column's order is reversed.

  PRE: 0 <= columnIndex < getColumnCount()

  Parameters:
    `columnIndex` - the columnIndex in view coordinates.

### setSortOrder

    public void setSortOrder(int columnIndex,
                             javax.swing.SortOrder sortOrder)

  Sorts the table by the given column using SortOrder. Delegates to the SortController if available, or does nothing if not.

  PRE: 0 <= columnIndex < getColumnCount()

  Parameters:
    `columnIndex` - the column index in view coordinates.
    `sortOrder` - the sort order to use.

### getSortOrder

    public javax.swing.SortOrder getSortOrder(int columnIndex)

  Returns the SortOrder of the given column. Delegates to the SortController if available, or returns SortOrder.UNSORTED if not.

  Parameters:
    `columnIndex` - the column index in view coordinates.
  Returns:
    the interactive sorter's SortOrder if matches the column or SortOrder.UNSORTED

### toggleSortOrder

    public void toggleSortOrder(java.lang.Object identifier)

  Toggles the sort order of the column with identifier. Delegates to the SortController if available, or does nothing if not.

  The exact behaviour of a toggle is defined by the SortController's toggleSortOrder implementation. Typically a unsorted column is sorted in ascending order, a sorted column's order is reversed.

  PENDING: JW - define the behaviour if the identifier is not found. This can happen if either there's no column at all with the identifier or if there's no column of type TableColumnExt. Currently does nothing, that is does not change sort state.

  Parameters:
    `identifier` - the column identifier.

### setSortOrder

    public void setSortOrder(java.lang.Object identifier,
                             javax.swing.SortOrder sortOrder)

  Sorts the table by the given column using the SortOrder. Delegates to the SortController, if available or does nothing if not.

  PENDING: JW - define the behaviour if the identifier is not found. This can happen if either there's no column at all with the identifier or if there's no column of type TableColumnExt. Currently does nothing, that is does not change sort state.

  Parameters:
    `identifier` - the column's identifier.
    `sortOrder` - the sort order to use. If null or SortOrder.UNSORTED, this method has the same effect as resetSortOrder();

### getSortOrder

    public javax.swing.SortOrder getSortOrder(java.lang.Object identifier)

  Returns the SortOrder of the given column. Delegates to the SortController if available, or returns SortOrder.UNSORTED if not.

  PENDING: JW - define the behaviour if the identifier is not found. This can happen if either there's no column at all with the identifier or if there's no column of type TableColumnExt. Currently returns SortOrder.UNSORTED.

  Parameters:
    `identifier` - the column's identifier.
  Returns:
    the interactive sorter's SortOrder if matches the column or SortOrder.UNSORTED

### isSortable

    @Deprecated
    protected boolean isSortable(int columnIndex)

  Deprecated.

  Decides if the column at columnIndex can be interactively sorted.

  Here: delegates to the SortController, if available. If not, returns true if both this table and the column sortable property is enabled, false otherwise.

  Note: as of post-1.0 this method is no longer used internally, as the responsibility to respect per-column/per-table sortability is moved to the SortController.

  Parameters:
    `columnIndex` - column in view coordinates
  Returns:
    boolean indicating whether or not the column is sortable in this table.

### isSortable

    @Deprecated
    protected boolean isSortable(java.lang.Object identifier)

  Deprecated.

  Decides if the column with identifier can be interactively sorted.

  Here: delegates to the SortController, if available. If not, returns true if both this table and the column sortable property is enabled, false otherwise.

  Note: as of post-1.0 this method is no longer used internally, as the responsibility to respect per-column/per-table sortability is moved to the SortController.

  Parameters:
    `identifier` - the column's identifier
  Returns:
    boolean indicating whether or not the column is sortable in this table.

### getSortController

    protected SortController<? extends javax.swing.table.TableModel> getSortController()

  Returns the currently active SortController. May be null, if the current RowSorter is not an instance of SortController.

  PENDING JW: generics - can't get the RowFilter getter signature correct with having controller typed here.

  PENDING JW: swaying about hiding or not - currently the only way to make the view not configure a RowSorter of type SortController is to let this return null.

  Returns:
    the currently active `SortController` may be null

### hasSortController

    protected boolean hasSortController()

  Returns a boolean indicating whether the table has a SortController. If true, the call to getSortController is guaranteed to return a not-null value.

  Returns:
    a boolean indicating whether the table has a SortController.
  See Also:
    `getSortController()`

### getControlsSorterProperties

    protected boolean getControlsSorterProperties()

  Returns a boolean indicating whether the table configures the sorter's properties. If true, guaranteed that table's and the columns' sort related properties are propagated to the sorter. If false, guaranteed to not touch the sorter's configuration.

  This implementation returns true if the sorter is of type SortController. Note: the synchronization is unidirection from the table to the sorter. Changing the sorter under the table's feet might lead to undefined behaviour.

  Returns:
    a boolean indicating whether the table configurers the sorter's properties.

### getSortedColumn

    public javax.swing.table.TableColumn getSortedColumn()

  Returns the primary sort column, or null if nothing sorted or no sortKey corresponds to a TableColumn currently contained in the TableColumnModel.

  Returns:
    the currently interactively sorted TableColumn or null if there is not sorter active or if the sorted column index does not correspond to any column in the TableColumnModel.

### columnAdded

    public void columnAdded(javax.swing.event.TableColumnModelEvent e)

  Overridden to propagate sort-related column properties to the SortController and to update string representation of column.

  PENDING JW: check correct update on visibility change!

  PENDING JW: need cleanup of string rep after column removed (if it's a real remove)

  Specified by:
    `columnAdded` in interface `javax.swing.event.TableColumnModelListener`
  Overrides:
    `columnAdded` in class `javax.swing.JTable`

### getColumn

    public javax.swing.table.TableColumn getColumn(int viewColumnIndex)

  Returns the `TableColumn` at view position `columnIndex`. The return value is not `null`.

  NOTE: This delegate method is added to protect developer's from unexpected exceptions in jdk1.5+. Super does not expose the `TableColumn` access by index which may lead to unexpected `IllegalArgumentException`: If client code assumes the delegate method is available, autoboxing will convert the given int to an Integer which will call the getColumn(Object) method.

  Parameters:
    `viewColumnIndex` - index of the column with the object in question
  Returns:
    the `TableColumn` object that matches the column index
  Throws:
    `java.lang.ArrayIndexOutOfBoundsException` - if viewColumnIndex out of allowed range.
  See Also:
    `JTable.getColumn(Object)`, `getColumnExt(int)`, `TableColumnModel.getColumn(int)`

### getColumns

    public java.util.List<javax.swing.table.TableColumn> getColumns()

  Returns a `List` of visible `TableColumn`s.

  Returns:
    a `List` of visible columns.
  See Also:
    `getColumns(boolean)`

### getColumnMargin

    public int getColumnMargin()

  Returns the margin between columns.

  Convenience to expose column model properties through `JXTable` api.

  Returns:
    the margin between columns
  See Also:
    `setColumnMargin(int)`, `TableColumnModel.getColumnMargin()`

### setColumnMargin

    public void setColumnMargin(int value)

  Sets the margin between columns. Convenience to expose column model properties through `JXTable` api.

  Parameters:
    `value` - margin between columns; must be greater than or equal to zero.
  See Also:
    `getColumnMargin()`, `TableColumnModel.setColumnMargin(int)`

### getColumnCount

    public int getColumnCount(boolean includeHidden)

  Returns the number of contained columns. The count includes or excludes invisible columns, depending on whether the `includeHidden` is true or false, respectively. If false, this method returns the same count as `getColumnCount()`. If the columnModel is not of type `TableColumnModelExt`, the parameter value has no effect.

  Parameters:
    `includeHidden` - a boolean to indicate whether invisible columns should be included
  Returns:
    the number of contained columns, including or excluding the invisible as specified.
  See Also:
    `JTable.getColumnCount()`, `TableColumnModelExt.getColumnCount(boolean)`

### getColumns

    public java.util.List<javax.swing.table.TableColumn> getColumns(boolean includeHidden)

  Returns a `List` of contained `TableColumn`s. Includes or excludes invisible columns, depending on whether the `includeHidden` is true or false, respectively. If false, an `Iterator` over the List is equivalent to the `Enumeration` returned by `getColumns()`. If the columnModel is not of type `TableColumnModelExt`, the parameter value has no effect.

  NOTE: the order of columns in the List depends on whether or not the invisible columns are included, in the former case it's the insertion order in the latter it's the current order of the visible columns.

  Parameters:
    `includeHidden` - a boolean to indicate whether invisible columns should be included
  Returns:
    a `List` of contained columns.
  See Also:
    `getColumns()`, `TableColumnModelExt.getColumns(boolean)`

### getColumnExt

    public TableColumnExt getColumnExt(java.lang.Object identifier)

  Returns the first `TableColumnExt` with the given `identifier`. The return value is null if there is no contained column with identifier or if the column with `identifier` is not of type `TableColumnExt`. The returned column may be visible or hidden.

  Parameters:
    `identifier` - the object used as column identifier
  Returns:
    first `TableColumnExt` with the given identifier or null if none is found
  See Also:
    `getColumnExt(int)`, `JTable.getColumn(Object)`, `TableColumnModelExt.getColumnExt(Object)`

### getColumnExt

    public TableColumnExt getColumnExt(int viewColumnIndex)

  Returns the `TableColumnExt` at view position `columnIndex`. The return value is null, if the column at position `columnIndex` is not of type `TableColumnExt`. The returned column is visible.

  Parameters:
    `viewColumnIndex` - the index of the column desired
  Returns:
    the `TableColumnExt` object that matches the column index
  Throws:
    `java.lang.ArrayIndexOutOfBoundsException` - if columnIndex out of allowed range, that is if `(columnIndex < 0) || (columnIndex >= getColumnCount())` .
  See Also:
    `getColumnExt(Object)`, `getColumn(int)`, `TableColumnModelExt.getColumnExt(int)`

### setColumnSequence

    public void setColumnSequence(java.lang.Object[] identifiers)

  Reorders the columns in the sequence given array. Logical names that do not correspond to any column in the model will be ignored. Columns with logical names not contained are added at the end. PENDING JW - do we want this? It's used by JNTable.

  Parameters:
    `identifiers` - array of logical column names
  See Also:
    `getColumns(boolean)`

### columnPropertyChange

    public void columnPropertyChange(java.beans.PropertyChangeEvent event)

  Notifies listeners about property changes of contained columns. The event is the original as fired from the `TableColumn`. Listens to column property changes.

  Specified by:
    `columnPropertyChange` in interface `TableColumnModelExtListener`
  Parameters:
    `event` - a `PropertyChangeEvent` fired by a `TableColumn` contained in a `TableColumnModel`

### createDefaultColumnsFromModel

    public final void createDefaultColumnsFromModel()

  Creates, configures and adds default `TableColumn`s for columns in this table's `TableModel`. Removes all currently contained `TableColumn`s. The exact type and configuration of the columns is controlled completely by the `ColumnFactory`. Client code can use `setColumnFactory(ColumnFactory)` to plug-in a custom ColumnFactory implementing their own default column creation and behaviour.

  Note: this method will probably become final (Issue #961-SwingX) so it's strongly recommended to not override now (and replace existing overrides by a custom ColumnFactory)!

  Overrides:
    `createDefaultColumnsFromModel` in class `javax.swing.JTable`
  See Also:
    `setColumnFactory(ColumnFactory)`, `ColumnFactory`

### getColumnFactory

    public ColumnFactory getColumnFactory()

  Returns the ColumnFactory.

  Returns:
    the columnFactory to use for column creation and configuration, guaranteed to not be null.
  See Also:
    `setColumnFactory(ColumnFactory)`, `ColumnFactory`

### setColumnFactory

    public void setColumnFactory(ColumnFactory columnFactory)

  Sets the `ColumnFactory` to use for column creation and configuration. The default value is the shared application ColumnFactory.

  Note: this method has no side-effect, that is existing columns are not re-created automatically, client code must trigger it manually.

  Parameters:
    `columnFactory` - the factory to use, `null` indicates to use the shared application factory.
  See Also:
    `getColumnFactory()`, `ColumnFactory`

### packTable

    public void packTable(int margin)

  Packs all the columns to their optimal size. Works best with auto resizing turned off.

  Parameters:
    `margin` - the margin to apply to each column.
  See Also:
    `packColumn(int, int)`, `packColumn(int, int, int)`

### packColumn

    public void packColumn(int column,
                           int margin)

  Packs an indivudal column in the table.

  Parameters:
    `column` - The Column index to pack in View Coordinates
    `margin` - The Margin to apply to the column width.
  See Also:
    `packColumn(int, int, int)`, `packTable(int)`

### packColumn

    public void packColumn(int column,
                           int margin,
                           int max)

  Packs an indivual column in the table to less than or equal to the maximum witdth. If maximum is -1 then the column is made as wide as it needs.

  Parameters:
    `column` - the column index to pack in view coordinates
    `margin` - the margin to apply to the column
    `max` - the maximum width the column can be resized to, -1 means no limit
  See Also:
    `packColumn(int, int)`, `packTable(int)`, `ColumnFactory.packColumn(JXTable, TableColumnExt, int, int)`

### getVisibleRowCount

    public int getVisibleRowCount()

  Returns the preferred number of rows to show in a `JScrollPane`.

  Returns:
    the number of rows to show in a `JScrollPane`
  See Also:
    `setVisibleRowCount(int)`

### setVisibleRowCount

    public void setVisibleRowCount(int visibleRowCount)

  Sets the preferred number of rows to show in a `JScrollPane`.

  This is a bound property. The default value is 20.

  PENDING: allow negative for use-all? Analogous to visColumnCount.

  Parameters:
    `visibleRowCount` - number of rows to show in a `JScrollPane`
  Throws:
    `java.lang.IllegalArgumentException` - if given count is negative.
  See Also:
    `getVisibleRowCount()`

### getVisibleColumnCount

    public int getVisibleColumnCount()

  Returns the preferred number of columns to show in the `JScrollPane`.

  Returns:
    the number of columns to show in the scroll pane.
  See Also:
    `setVisibleColumnCount(int)`

### setVisibleColumnCount

    public void setVisibleColumnCount(int visibleColumnCount)

  Sets the preferred number of Columns to show in a `JScrollPane`. A negative number is interpreted as use-all available visible columns.

  This is a bound property. The default value is -1 (effectively the same as before the introduction of this property).

  Parameters:
    `visibleColumnCount` - number of rows to show in a `JScrollPane`
  See Also:
    `getVisibleColumnCount()`

### setPreferredScrollableViewportSize

    public void setPreferredScrollableViewportSize(java.awt.Dimension size)

  If the given dimension is null, the auto-calculation of the pref scrollable size is enabled, otherwise the behaviour is the same as super. The default is auto-calc enabled on.

  Overrides:
    `setPreferredScrollableViewportSize` in class `javax.swing.JTable`
  See Also:
    `getPreferredScrollableViewportSize()`

### getPreferredScrollableViewportSize

    public java.awt.Dimension getPreferredScrollableViewportSize()

  Overridden to support auto-calculation of pref scrollable size, dependent on the visible row/column count properties. The auto-calc is on if there's no explicit pref scrollable size set. Otherwise the fixed size is returned

  The calculation of the preferred scrollable width is delegated to the ColumnFactory to allow configuration with custom strategies implemented in custom factories.

  Specified by:
    `getPreferredScrollableViewportSize` in interface `javax.swing.Scrollable`
  Overrides:
    `getPreferredScrollableViewportSize` in class `javax.swing.JTable`
  See Also:
    `setPreferredScrollableViewportSize(Dimension)`, `ColumnFactory.getPreferredScrollableViewportWidth(JXTable)`

### initializeColumnWidths

    protected void initializeColumnWidths()

  Initialize the width related properties of all contained TableColumns, both visible and hidden.

  - PENDING: move into ColumnFactory?
  - PENDING: what to do if autoCreateColumn off?
  - PENDING: public? to allow manual setting of column properties which might effect their default sizing. Needed in testing - but real-world? the factory is meant to do the property setting, based on tableModel and meta-data (from where?). But leads to funny call sequence for per-table factory (new JXTable(), table.setColumnFactory(..), table.setModel(...))

  See Also:
    `initializeColumnPreferredWidth(TableColumn)`

### initializeColumnPreferredWidth

    protected void initializeColumnPreferredWidth(javax.swing.table.TableColumn column)

  Initialize the width related properties of the specified column. The details are specified by the current `ColumnFactory` if the column is of type `TableColumnExt`. Otherwise nothing is changed.

  TODO JW - need to cleanup getScrollablePreferred (refactor and inline)

  Parameters:
    `column` - TableColumn object representing view column
  See Also:
    `ColumnFactory.configureColumnWidths(org.jdesktop.swingx.JXTable, org.jdesktop.swingx.table.TableColumnExt)`

### scrollRowToVisible

    public void scrollRowToVisible(int row)

  Scrolls vertically to make the given row visible. This might not have any effect if the table isn't contained in a `JViewport`.

  Note: this method has no precondition as it internally uses `getCellRect` which is lenient to off-range coordinates.

  Parameters:
    `row` - the view row index of the cell
  See Also:
    `scrollColumnToVisible(int)`, `scrollCellToVisible(int, int)`, `JComponent.scrollRectToVisible(Rectangle)`

### scrollColumnToVisible

    public void scrollColumnToVisible(int column)

  Scrolls horizontally to make the given column visible. This might not have any effect if the table isn't contained in a `JViewport`.

  Note: this method has no precondition as it internally uses `getCellRect` which is lenient to off-range coordinates.

  Parameters:
    `column` - the view column index of the cell
  See Also:
    `scrollRowToVisible(int)`, `scrollCellToVisible(int, int)`, `JComponent.scrollRectToVisible(Rectangle)`

### scrollCellToVisible

    public void scrollCellToVisible(int row,
                                    int column)

  Scrolls to make the cell at row and column visible. This might not have any effect if the table isn't contained in a `JViewport`.

  Note: this method has no precondition as it internally uses `getCellRect` which is lenient to off-range coordinates.

  Parameters:
    `row` - the view row index of the cell
    `column` - the view column index of the cell
  See Also:
    `scrollColumnToVisible(int)`, `scrollRowToVisible(int)`, `JComponent.scrollRectToVisible(Rectangle)`

### getSelectionMode

    public int getSelectionMode()

  Returns the selection mode used by this table's selection model.

  PENDING JW - setter?

  Returns:
    the selection mode used by this table's selection model
  See Also:
    `ListSelectionModel.getSelectionMode()`

### doFind

    protected void doFind()

  Starts a search on this List's visible items. This implementation asks the SearchFactory to open a find widget on itself.

### getSearchable

    public Searchable getSearchable()

  Returns a Searchable for this component, guaranteed to be not null. This implementation lazily creates a TableSearchable if necessary.

  Returns:
    a not-null Searchable for this component.
  See Also:
    `setSearchable(Searchable)`, `TableSearchable`

### setSearchable

    public void setSearchable(Searchable searchable)

  Sets the Searchable for this table. If null, a default searchable will be used.

  Parameters:
    `searchable` - the Searchable to use for this table, may be null to indicate using the table's default searchable.

### getComponentAdapter

    protected ComponentAdapter getComponentAdapter()

  Returns:
    the unconfigured ComponentAdapter.

### getComponentAdapter

    protected ComponentAdapter getComponentAdapter(int row,
                                                   int column)

  Convenience to access a configured ComponentAdapter.

  Parameters:
    `row` - the row index in view coordinates.
    `column` - the column index in view coordinates.
  Returns:
    the configured ComponentAdapter.

### setHighlighters

    public void setHighlighters(Highlighter... highlighters)

  Sets the `Highlighter`s to the table, replacing any old settings. None of the given Highlighters must be null.

  This is a bound property.

  Note: as of version #1.257 the null constraint is enforced strictly. To remove all highlighters use this method without param.

  Parameters:
    `highlighters` - zero or more not null highlighters to use for renderer decoration.
  Throws:
    `java.lang.NullPointerException` - if array is null or array contains null values.
  See Also:
    `getHighlighters()`, `addHighlighter(Highlighter)`, `removeHighlighter(Highlighter)`

### getHighlighters

    public Highlighter[] getHighlighters()

  Returns the `Highlighter`s used by this table. Maybe empty, but guarantees to be never null.

  Returns:
    the Highlighters used by this table, guaranteed to never null.
  See Also:
    `setHighlighters(Highlighter[])`

### addHighlighter

    public void addHighlighter(Highlighter highlighter)

  Appends a `Highlighter` to the end of the list of used `Highlighter`s. The argument must not be null.

  Parameters:
    `highlighter` - the `Highlighter` to add, must not be null.
  Throws:
    `java.lang.NullPointerException` - if `Highlighter` is null.
  See Also:
    `removeHighlighter(Highlighter)`, `setHighlighters(Highlighter[])`

### removeHighlighter

    public void removeHighlighter(Highlighter highlighter)

  Removes the given Highlighter.

  Does nothing if the Highlighter is not contained.

  Parameters:
    `highlighter` - the Highlighter to remove.
  See Also:
    `addHighlighter(Highlighter)`, `setHighlighters(Highlighter...)`

### getCompoundHighlighter

    protected CompoundHighlighter getCompoundHighlighter()

  Returns the CompoundHighlighter assigned to the table, null if none. PENDING: open up for subclasses again?.

  Returns:
    the CompoundHighlighter assigned to the table.

### getHighlighterChangeListener

    protected javax.swing.event.ChangeListener getHighlighterChangeListener()

  Returns the `ChangeListener` to use with highlighters. Lazily creates the listener.

  Returns:
    the ChangeListener for observing changes of highlighters, guaranteed to be `not-null`

### createHighlighterChangeListener

    protected javax.swing.event.ChangeListener createHighlighterChangeListener()

  Creates and returns the ChangeListener observing Highlighters.

  Here: repaints the table on receiving a stateChanged.

  Returns:
    the ChangeListener defining the reaction to changes of highlighters.

### getStringValueRegistry

    protected StringValueRegistry getStringValueRegistry()

  Returns the StringValueRegistry which defines the string representation for each cells. This is strictly for internal use by the table, which has the responsibility to keep in synch with registered renderers.

  Currently exposed for testing reasons, client code is recommended to not use nor override.

  Returns:

### createDefaultStringValueRegistry

    protected StringValueRegistry createDefaultStringValueRegistry()

  Creates and returns the default registry for StringValues.

  Returns:
    the default registry for StringValues.

### setDefaultRenderer

    public void setDefaultRenderer(java.lang.Class<?> columnClass,
                                   javax.swing.table.TableCellRenderer renderer)

  Overridden to synchronize the string representation. If the renderer is of type StringValue a mapping it will be used as converter for the class type. If not, the mapping is reset to default.

  Overrides:
    `setDefaultRenderer` in class `javax.swing.JTable`

### getStringAt

    public java.lang.String getStringAt(int row,
                                        int column)

  Returns the string representation of the cell value at the given position.

  Parameters:
    `row` - the row index of the cell in view coordinates
    `column` - the column index of the cell in view coordinates.
  Returns:
    the string representation of the cell value as it will appear in the table.

### getCellRenderer

    public javax.swing.table.TableCellRenderer getCellRenderer(int row,
                                                               int column)

  Overridden to fix core bug #4614616 (NPE if `TableModel`'s `Class` for the column is an interface). This method guarantees to always return a `not null` value. Returns the default renderer for `Object` if super returns `null`.

  Note: The lookup strategy for is unchanged compared to super. Subclasses which override this with a different lookup strategy are strongly advised to implement a custom StringValueRegistry with that lookup strategy to keep the WYSIWYM in SwingX.

  Overrides:
    `getCellRenderer` in class `javax.swing.JTable`

### prepareRenderer

    public java.awt.Component prepareRenderer(javax.swing.table.TableCellRenderer renderer,
                                              int row,
                                              int column)

  Returns the decorated `Component` used as a stamp to render the specified cell. Overrides superclass version to provide support for cell decorators.

  Adjusts component orientation (guaranteed to happen before applying Highlighters).

  Per-column highlighters contained in `TableColumnExt.getHighlighters()` are applied to the renderer after the table highlighters.

  TODO kgs: interaction of search highlighter and column highlighters

  Note: DefaultTableCellRenderer and subclasses require a hack to play nicely with Highlighters because it has an internal "color memory" in setForeground/setBackground. The hack is applied in `resetDefaultTableCellRendererColors` which is called after super.prepareRenderer and before applying the Highlighters. The method is called always and for all renderers.

  Overrides:
    `prepareRenderer` in class `javax.swing.JTable`
  Parameters:
    `renderer` - the `TableCellRenderer` to prepare
    `row` - the row of the cell to render, where 0 is the first row
    `column` - the column of the cell to render, where 0 is the first column
  Returns:
    the decorated `Component` used as a stamp to render the specified cell
  See Also:
    `resetDefaultTableCellRendererColors(Component, int, int)`, `Highlighter`

### resetDefaultTableCellRendererColors

    protected void resetDefaultTableCellRendererColors(java.awt.Component renderer,
                                                       int row,
                                                       int column)

  Method to apply a hack around DefaultTableCellRenderer "color memory" (Issue #258-swingx). Applies the hack if the client property `USE_DTCR_COLORMEMORY_HACK` having the value of `Boolean.TRUE`, does nothing otherwise. The property is true by default.

  The hack consists of applying a specialized `Highlighter` to force reset the color "memory" of `DefaultTableCellRenderer`. Note that the hack is applied always, that is even if there are no custom Highlighters.

  Client code which solves the problem at the core (that is in a well-behaved `DefaultTableCellRenderer`) can disable the hack by removing the client property or by subclassing and override this to do nothing.

  Parameters:
    `renderer` - the `TableCellRenderer` to hack
    `row` - the row of the cell to render
    `column` - the column index of the cell to render
  See Also:
    `prepareRenderer(TableCellRenderer, int, int)`, `USE_DTCR_COLORMEMORY_HACK`, `ResetDTCRColorHighlighter`

### prepareEditor

    public java.awt.Component prepareEditor(javax.swing.table.TableCellEditor editor,
                                            int row,
                                            int column)

  Overridden to adjust the editor's component orientation.

  Overrides:
    `prepareEditor` in class `javax.swing.JTable`

### adjustComponentOrientation

    protected void adjustComponentOrientation(java.awt.Component stamp)

  Adjusts the `Component`'s orientation to this `JXTable`'s CO if appropriate. The parameter must not be `null`.

  This implementation synchs the CO always.

  Parameters:
    `stamp` - the `Component` who's CO may need to be synched, must not be `null`.

### getNewDefaultRenderer

    @Deprecated
    public javax.swing.table.TableCellRenderer getNewDefaultRenderer(java.lang.Class<?> columnClass)

  Deprecated. not working anyway - no replacement.

  Returns a new instance of the default renderer for the specified class. This differs from `getDefaultRenderer()` in that it returns a new instance each time so that the renderer may be set and customized on a particular column.

  NOTE: this doesn't work with swingx renderers! Do we really need it? It had been used in JNTable which is practically obsolete. If needed, we could make all renderer support classes clonable.

  Parameters:
    `columnClass` - Class of value being rendered
  Returns:
    TableCellRenderer instance which renders values of the specified type
  See Also:
    `JTable.getDefaultRenderer(Class)`

### createDefaultRenderers

    protected void createDefaultRenderers()

  Creates default cell renderers for `Object`s, `Number`s, `Date`s, `Boolean`s, and `Icon/Image/`s.

  Overridden to install SwingX renderers plus hacking around huge memory consumption of UIDefaults (see #6345050 in core Bug parade)

  Overrides:
    `createDefaultRenderers` in class `javax.swing.JTable`
  See Also:
    `DefaultTableRenderer`, `ComponentProvider`

### createDefaultEditors

    protected void createDefaultEditors()

  Creates default cell editors for objects, numbers, and boolean values.

  Overridden to hook enhanced editors (f.i. `NumberEditorExt` )plus hacking around huge memory consumption of UIDefaults (see #6345050 in core Bug parade)

  Overrides:
    `createDefaultEditors` in class `javax.swing.JTable`
  See Also:
    `DefaultCellEditor`

### isEditable

    public boolean isEditable()

  Returns the editable property of the `JXTable` as a whole.

  Returns:
    boolean to indicate if the table is editable.
  See Also:
    `setEditable(boolean)`

### setEditable

    public void setEditable(boolean editable)

  Sets the editable property. This property allows to mark all cells in a table as read-only, independent of their per-column editability as returned by `TableColumnExt.isEditable` and their per-cell editability as returned by the `TableModel.isCellEditable`. If a cell is read-only in its column or model layer, this property has no effect.

  The default value is `true`.

  Parameters:
    `editable` - the flag to indicate if the table is editable.
  See Also:
    `isEditable()`, `isCellEditable(int, int)`

### isTerminateEditOnFocusLost

    public boolean isTerminateEditOnFocusLost()

  Returns the property which determines the edit termination behaviour on focus lost.

  Returns:
    boolean to indicate whether an ongoing edit should be terminated if the focus is moved to somewhere outside of the table.
  See Also:
    `setTerminateEditOnFocusLost(boolean)`

### setTerminateEditOnFocusLost

    public void setTerminateEditOnFocusLost(boolean terminate)

  Sets the property to determine whether an ongoing edit should be terminated if the focus is moved to somewhere outside of the table. If true, terminates the edit, does nothing otherwise. The exact behaviour is implemented in `JTable.CellEditorRemover`: "outside" is interpreted to be on a component which is not under the table hierarchy but inside the same toplevel window, "terminate" does so in any case, first tries to stop the edit, if that's unsuccessful it cancels the edit.

  The default value is `true`.

  Parameters:
    `terminate` - the flag to determine whether or not to terminate the edit
  See Also:
    `isTerminateEditOnFocusLost()`

### isAutoStartEditOnKeyStroke

    public boolean isAutoStartEditOnKeyStroke()

  Returns the autoStartsEdit property.

  Returns:
    boolean to indicate whether a keyStroke should try to start editing.
  See Also:
    `setAutoStartEditOnKeyStroke(boolean)`

### setAutoStartEditOnKeyStroke

    public void setAutoStartEditOnKeyStroke(boolean autoStart)

  Sets the autoStartsEdit property. If true, keystrokes are passed-on to the cellEditor of the lead cell to let it decide whether to start an edit.

  The default value is `true`.

  Parameters:
    `autoStart` - boolean to determine whether a keyStroke should try to start editing.
  See Also:
    `isAutoStartEditOnKeyStroke()`

### editCellAt

    public boolean editCellAt(int row,
                              int column,
                              java.util.EventObject e)

  overridden to install a custom editor remover.

  Overrides:
    `editCellAt` in class `javax.swing.JTable`

### removeEditor

    public void removeEditor()

  Overridden with backport from Mustang fix for #4684090, #4887999.

  Overrides:
    `removeEditor` in class `javax.swing.JTable`

### removeNotify

    public void removeNotify()

  Overridden to uninstall the custom editor remover.

  Overrides:
    `removeNotify` in class `javax.swing.JTable`

### isFocusCycleRoot

    public boolean isFocusCycleRoot()

  Overridden to prevent spurious focus loss to outside of table while removing the editor. This is essentially a hack around core bug #6210779. PENDING: add link to wiki!

  Overrides:
    `isFocusCycleRoot` in class `java.awt.Container`

### transferFocus

    public void transferFocus()

  Overridden to try to stop the edit, if appropriate. Calls super if succeeded, does not yield otherwise.

  Overrides:
    `transferFocus` in class `java.awt.Component`

### transferFocusBackward

    public void transferFocusBackward()

  Overridden to try to stop the edit, if appropiate. Calls super if succeeded, does not yield otherwise.

  Overrides:
    `transferFocusBackward` in class `java.awt.Container`

### updateUI

    public void updateUI()

  Additionally updates auto-adjusted row height and highlighters.

  Another of the override motivation is to fix core issue (?? ID): super fails to update all renderers/editors.

  Overrides:
    `updateUI` in class `javax.swing.JTable`

### updateColumnControlUI

    protected void updateColumnControlUI()

  Updates the ui of the columnControl if appropriate.

### updateColumnUI

    protected void updateColumnUI(javax.swing.table.TableColumn column)

  Updates TableColumn after updateUI changes. This implementation delegates to the column if it is of type UIDependent, takes over to try an update of the column's cellEditor, Cell-/HeaderRenderer otherwise.

  Parameters:
    `column` - the tableColumn to update.

### updateHighlighterUI

    protected void updateHighlighterUI()

  Updates highlighter after `updateUI` changes.

  See Also:
    `UIDependent`

### updateRowHeightUI

    protected void updateRowHeightUI(boolean respectRowSetFlag)

  Auto-adjusts rowHeight to something more pleasing then the default. This method is called after instantiation and after updating the UI. Does nothing if the given parameter is `true` and the rowHeight had been already set by client code. The underlying problem is that raw types can't implement UIResource.

  This implementation asks the UIManager for a default value (stored with key "JXTable.rowHeight"). If none is available, calculates a "reasonable" height from the table's fontMetrics, assuming that most renderers/editors will have a border with top/bottom of 1.

  Parameters:
    `respectRowSetFlag` - a boolean to indicate whether client-code flag should be respected.
  See Also:
    `isXTableRowHeightSet`

### setShowGrid

    public void setShowGrid(boolean showHorizontalLines,
                            boolean showVerticalLines)

  Convenience to set both grid line visibility and default margin for horizontal/vertical lines. The margin defaults to 1 or 0 if the grid lines are drawn or not drawn.

  Parameters:
    `showHorizontalLines` - boolean to decide whether to draw horizontal grid lines.
    `showVerticalLines` - boolean to decide whether to draw vertical grid lines.
  See Also:
    `JTable.setShowGrid(boolean)`, `JTable.setIntercellSpacing(Dimension)`

### setShowGrid

    public void setShowGrid(boolean showGrid)

  Behaves exactly like super.

  It's overridden to warn against a frequent programming error: this method toggles only the visibility of the grid lines, it does not update the row/column margins - which may lead to visual artefacts, as f.i. not showing the lines at all or showing normal table background in selected state where the lines should have been.

  Overrides:
    `setShowGrid` in class `javax.swing.JTable`
  See Also:
    `setShowGrid(boolean, boolean)`

### setRowHeight

    public void setRowHeight(int rowHeight)

  Overriden to mark the request as client-code induced.

  Overrides:
    `setRowHeight` in class `javax.swing.JTable`
  See Also:
    `isXTableRowHeightSet`

### setRowHeightEnabled

    @Deprecated
    public void setRowHeightEnabled(boolean enabled)

  Deprecated. no longer necessary (switched to 1.6)

  Sets enablement of individual rowHeight support. Enabling the support involves reflective access to super's private field rowModel which may fail due to security issues. If failing the support is not enabled.

  The default value is `false`.

  Parameters:
    `enabled` - a boolean to indicate whether per-row heights should be enabled.
  See Also:
    `isRowHeightEnabled()`, `JTable.setRowHeight(int, int)`

### isRowHeightEnabled

    @Deprecated
    public boolean isRowHeightEnabled()

  Deprecated. no longer necessary (switched to 1.6)

  Returns a boolean to indicate whether individual row height is enabled.

  Returns:
    a boolean to indicate whether individual row height support is enabled, always true
  See Also:
    `setRowHeightEnabled(boolean)`

### adminSetRowHeight

    protected void adminSetRowHeight(int rowHeight)

  Sets the rowHeight for all rows to the given value. Keeps the flag `isXTableRowHeight` unchanged. This enables the distinction between setting the height for internal reasons from doing so by client code.

  Parameters:
    `rowHeight` - new height in pixel.
  See Also:
    `setRowHeight(int)`, `isXTableRowHeightSet`

### rowAtPoint

    public int rowAtPoint(java.awt.Point point)

  Overridden to work around core Bug (ID #6291631): negative y is mapped to row 0).

  Overrides:
    `rowAtPoint` in class `javax.swing.JTable`

### createDefaultTableHeader

    protected javax.swing.table.JTableHeader createDefaultTableHeader()

  Overridden to return a `JXTableHeader`.

  Overrides:
    `createDefaultTableHeader` in class `javax.swing.JTable`
  See Also:
    `JXTableHeader`

### createDefaultColumnModel

    protected javax.swing.table.TableColumnModel createDefaultColumnModel()

  Overridden to return a `DefaultTableColumnModelExt`.

  Overrides:
    `createDefaultColumnModel` in class `javax.swing.JTable`
  See Also:
    `DefaultTableColumnModelExt`

### setSelectionBackground

    public void setSelectionBackground(java.awt.Color selectionBackground)

  Overridden because super throws NPE on null param.

  Overrides:
    `setSelectionBackground` in class `javax.swing.JTable`

### setSelectionForeground

    public void setSelectionForeground(java.awt.Color selectionForeground)

  Overridden because super throws NPE on null param.

  Overrides:
    `setSelectionForeground` in class `javax.swing.JTable`

### setGridColor

    public void setGridColor(java.awt.Color gridColor)

  Overridden because super throws NPE on null param.

  Overrides:
    `setGridColor` in class `javax.swing.JTable`

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.