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.table
Class ColumnFactory

    java.lang.Object
      org.jdesktop.swingx.table.ColumnFactory

    public class ColumnFactory

extends java.lang.Object

Creates and configures `TableColumnExt`s.

TODO JW: explain types of configuration - initial from tableModel, initial from table context, user triggered at runtime.

`JXTable` delegates all `TableColumn` creation and configuration to a `ColumnFactory`. Enhanced column configuration should be implemented in a custom factory subclass. The example beautifies the column titles to always start with a capital letter:

        MyColumnFactory extends ColumnFactory {
            //@Override
            public void configureTableColumn(TableModel model,
                TableColumnExt columnExt) {
                super.configureTableColumn(model, columnExt);
                String title = columnExt.getTitle();
                title = title.substring(0,1).toUpperCase() + title.substring(1).toLowerCase();
                columnExt.setTitle(title);
            }
        };

By default a single instance is shared across all tables of an application. This instance can be replaced by a custom implementation, preferably "early" in the application's lifetime.

     ColumnFactory.setInstance(new MyColumnFactory());

Alternatively, any instance of `JXTable` can be configured individually with its own `ColumnFactory`.

     JXTable table = new JXTable();
     table.setColumnFactory(new MyColumnFactory());
     table.setModel(myTableModel);

Author:
  Jeanette Winzenburg, M.Hillary (the pack code)
See Also:
  `JXTable.setColumnFactory(ColumnFactory)`

Constructor Summary
`ColumnFactory()`

Method Summary
`protected int` | `calcHeaderWidth(JXTable table, TableColumnExt columnExt)` Measures and returns the preferred width of the header.
`protected int` | `calcPrototypeWidth(JXTable table, TableColumnExt columnExt)` Measures and returns the preferred width of the rendering component configured with the prototype value, if any.
`void` | `configureColumnWidths(JXTable table, TableColumnExt columnExt)` Configures column initial widths properties from `JXTable`.
`void` | `configureTableColumn(javax.swing.table.TableModel model, TableColumnExt columnExt)` Configure column properties from TableModel.
`TableColumnExt` | `createAndConfigureTableColumn(javax.swing.table.TableModel model, int modelIndex)` Creates and configures a TableColumnExt.
`TableColumnExt` | `createTableColumn(int modelIndex)` Creates a table column with modelIndex.
`protected javax.swing.table.TableCellRenderer` | `getCellRenderer(JXTable table, TableColumnExt columnExt)` Returns the cell renderer to use for measuring.
`int` | `getDefaultPackMargin()` Returns the default pack margin.
`protected javax.swing.table.TableCellRenderer` | `getHeaderRenderer(JXTable table, TableColumnExt columnExt)` Looks up and returns the renderer used for the column's header.
`static ColumnFactory` | `getInstance()` Returns the shared default factory.
`int` | `getPreferredScrollableViewportWidth(JXTable table)` Calculates and returns the preferred scrollable viewport width of the given table.
`protected int` | `getRowCount(JXTable table)` Returns the number of table view rows accessible during row-related config.
`void` | `packColumn(JXTable table, TableColumnExt columnExt, int margin, int max)` Configures the column's `preferredWidth` to fit the content.
`void` | `setDefaultPackMargin(int margin)` Sets the default pack margin.
`static void` | `setInstance(ColumnFactory factory)` Sets the shared default factory.

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

Constructor Detail

### ColumnFactory

    public ColumnFactory()

Method Detail

### getInstance

    public static ColumnFactory getInstance()

  Returns the shared default factory.

  Returns:
    the shared instance of `ColumnFactory`
  See Also:
    `setInstance(ColumnFactory)`

### setInstance

    public static void setInstance(ColumnFactory factory)

  Sets the shared default factory. The shared instance is used by `JXTable` if none has been set individually.

  Parameters:
    `factory` - the default column factory.
  See Also:
    `getInstance()`, `JXTable.getColumnFactory()`

### createAndConfigureTableColumn

    public TableColumnExt createAndConfigureTableColumn(javax.swing.table.TableModel model,
                                                        int modelIndex)

  Creates and configures a TableColumnExt. `JXTable` calls this method for each column in the `TableModel`.

  Parameters:
    `model` - the TableModel to read configuration properties from
    `modelIndex` - column index in model coordinates
  Returns:
    a TableColumnExt to use for the modelIndex
  Throws:
    `NPE` - if model == null
    `java.lang.IllegalStateException` - if the modelIndex is invalid (in coordinate space of the tablemodel)
  See Also:
    `createTableColumn(int)`, `configureTableColumn(TableModel, TableColumnExt)`, `JXTable.createDefaultColumnsFromModel()`

### createTableColumn

    public TableColumnExt createTableColumn(int modelIndex)

  Creates a table column with modelIndex.

  The factory's column creation is passed through this method, so subclasses can override to return custom column types.

  Parameters:
    `modelIndex` - column index in model coordinates
  Returns:
    a TableColumnExt with `modelIndex`
  See Also:
    `createAndConfigureTableColumn(TableModel, int)`

### configureTableColumn

    public void configureTableColumn(javax.swing.table.TableModel model,
                                     TableColumnExt columnExt)

  Configure column properties from TableModel. This implementation sets the column's `headerValue` property from the model's `columnName`.

  The factory's initial column configuration is passed through this method, so subclasses can override to customize.

  Parameters:
    `model` - the TableModel to read configuration properties from
    `columnExt` - the TableColumnExt to configure.
  Throws:
    `java.lang.NullPointerException` - if model or column == null
    `java.lang.IllegalStateException` - if column does not have valid modelIndex (in coordinate space of the tablemodel)
  See Also:
    `createAndConfigureTableColumn(TableModel, int)`

### configureColumnWidths

    public void configureColumnWidths(JXTable table,
                                      TableColumnExt columnExt)

  Configures column initial widths properties from `JXTable`. This implementation sets the column's `preferredWidth` with the strategy:
  if the column has a prototype, measure the rendering component with the prototype as value and use that as pref width
  if the column has no prototype, use the standard magic pref width (= 75)
  try to measure the column's header and use it's preferred width if it exceeds the former.
  TODO JW - rename method to better convey what's happening, maybe initializeColumnWidths like the old method in JXTable.

  TODO JW - how to handle default settings which are different from standard 75?

  Parameters:
    `table` - the context the column will live in.
    `columnExt` - the Tablecolumn to configure.
  See Also:
    `JXTable.getPreferredScrollableViewportSize()`

### getPreferredScrollableViewportWidth

    public int getPreferredScrollableViewportWidth(JXTable table)

  Calculates and returns the preferred scrollable viewport width of the given table. Subclasses are free to override and implement a custom strategy.

  This implementation sums the pref widths of the first visibleColumnCount contained visible tableColumns. If the table contains less columns, the standard preferred width per column is added to the result.

  Parameters:
    `table` - the table containing the columns

### calcHeaderWidth

    protected int calcHeaderWidth(JXTable table,
                                  TableColumnExt columnExt)

  Measures and returns the preferred width of the header. Returns -1 if not applicable.

  Parameters:
    `table` - the component the renderer lives in
    `columnExt` - the TableColumn to configure
  Returns:
    the preferred width of the header or -1 if none.

### calcPrototypeWidth

    protected int calcPrototypeWidth(JXTable table,
                                     TableColumnExt columnExt)

  Measures and returns the preferred width of the rendering component configured with the prototype value, if any. Returns -1 if not applicable.

  Parameters:
    `table` - the component the renderer lives in
    `columnExt` - the TableColumn to configure
  Returns:
    the preferred width of the prototype or -1 if none.

### getCellRenderer

    protected javax.swing.table.TableCellRenderer getCellRenderer(JXTable table,
                                                                  TableColumnExt columnExt)

  Returns the cell renderer to use for measuring. Delegates to JXTable for visible columns, duplicates table logic for hidden columns.

  Parameters:
    `table` - the table which provides the renderer
    `columnExt` - the TableColumn to configure
  Returns:
    returns a cell renderer for measuring.

### getHeaderRenderer

    protected javax.swing.table.TableCellRenderer getHeaderRenderer(JXTable table,
                                                                    TableColumnExt columnExt)

  Looks up and returns the renderer used for the column's header.

  Parameters:
    `table` - the table which contains the column
    `columnExt` - the column to lookup the header renderer for
  Returns:
    the renderer for the columns header, may be null.

### packColumn

    public void packColumn(JXTable table,
                           TableColumnExt columnExt,
                           int margin,
                           int max)

  Configures the column's `preferredWidth` to fit the content. It respects the table context, a margin to add and a maximum width. This is typically called in response to a user gesture to adjust the column's width to the "widest" cell content of a column.

  This implementation loops through all rows of the given column and measures the renderers pref width (it's a potential performance sink). Subclasses can override to implement a different strategy.

  Note: though 2 * margin is added as spacing, this does not imply a left/right symmetry - it's up to the table to place the renderer and/or the renderer/highlighter to configure a border.

  PENDING: support pack for hidden column? This implementation can't handle it! For now, added doc and fail-fast.

  Parameters:
    `table` - the context the column will live in.
    `columnExt` - the column to configure.
    `margin` - the extra spacing to add twice, if -1 uses this factories default
    `max` - an upper limit to preferredWidth, -1 is interpreted as no limit
  Throws:
    `java.lang.IllegalStateException` - if column is not visible
  See Also:
    `setDefaultPackMargin(int)`, `JXTable.packTable(int)`, `JXTable.packColumn(int, int)`

### getRowCount

    protected int getRowCount(JXTable table)

  Returns the number of table view rows accessible during row-related config. All row-related access is bounded by the value returned from this method. Here: delegates to table.getRowCount().

  Subclasses can override to reduce the number (for performance) or support restrictions due to lazy loading, f.i. Implementors must guarantee that view row access with `0 <= row < getRowCount(JXTable)` succeeds.

  Parameters:
    `table` - the table to access
  Returns:
    valid rowCount

### getDefaultPackMargin

    public int getDefaultPackMargin()

  Returns the default pack margin.

  Returns:
    the default pack margin to use in packColumn.
  See Also:
    `setDefaultPackMargin(int)`

### setDefaultPackMargin

    public void setDefaultPackMargin(int margin)

  Sets the default pack margin.

  Note: this is not really a margin in the sense of symmetrically adding white space to the left/right of a cell's content. It's simply an amount of space which is added twice to the measured widths in packColumn.

  Parameters:
    `margin` - the default marging to use in packColumn.
  See Also:
    `getDefaultPackMargin()`, `packColumn(JXTable, TableColumnExt, int, int)`

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.