public TableColumn() 
{
//
// Constructors
//
        this(0);
}

Cover method, using a default model index of 0, default width of 75, a null renderer and a null editor. This method is intended for serialization.

Also see:

TableColumn(int, int, TableCellRenderer, TableCellEditor)

 public TableColumn(int modelIndex) 
{
        this(modelIndex, 75, null, null);
}

Cover method, using a default width of 75, a null renderer and a null editor.

Also see:

TableColumn(int, int, TableCellRenderer, TableCellEditor)

 public TableColumn(int modelIndex,
    int width) 
{
        this(modelIndex, width, null, null);
}

Cover method, using a null renderer and a null editor.

Also see:

TableColumn(int, int, TableCellRenderer, TableCellEditor)

 public TableColumn(int modelIndex,
    int width,
    TableCellRenderer cellRenderer,
    TableCellEditor cellEditor) 
{
        super();
        this.modelIndex = modelIndex;
        preferredWidth = this.width = Math.max(width, 0);
        this.cellRenderer = cellRenderer;
        this.cellEditor = cellEditor;
        // Set other instance variables to default values.
        minWidth = Math.min(15, this.width);
        maxWidth = Integer.MAX_VALUE;
        isResizable = true;
        resizedPostingDisableCount = 0;
        headerValue = null;
}

Creates and initializes an instance of TableColumn with the specified model index, width, cell renderer, and cell editor; all TableColumn constructors delegate to this one. The value of width is used for both the initial and preferred width; if width is negative, they're set to 0. The minimum width is set to 15 unless the initial width is less, in which case the minimum width is set to the initial width.

When the cellRenderer or cellEditor parameter is null, a default value provided by the JTable getDefaultRenderer or getDefaultEditor method, respectively, is used to provide defaults based on the type of the data in this column. This column-centric rendering strategy can be circumvented by overriding the getCellRenderer methods in JTable.

Parameters:

modelIndex - the index of the column in the model that supplies the data for this column in the table; the model index remains the same even when columns are reordered in the view

width - this column's preferred width and initial width

cellRenderer - the object used to render values in this column

cellEditor - the object used to edit values in this column

Also see:

getMinWidth()
JTable#getDefaultRenderer(Class)
JTable#getDefaultEditor(Class)
JTable#getCellRenderer(int, int)
JTable#getCellEditor(int, int)

 public synchronized  void addPropertyChangeListener(PropertyChangeListener listener) 
{
        if (changeSupport == null) {
            changeSupport = new SwingPropertyChangeSupport(this);
        }
        changeSupport.addPropertyChangeListener(listener);
}

Adds a PropertyChangeListener to the listener list. The listener is registered for all properties.

A PropertyChangeEvent will get fired in response to an explicit call to setFont, setBackground, or setForeground on the current component. Note that if the current component is inheriting its foreground, background, or font from its container, then no event will be fired in response to a change in the inherited property.

 protected TableCellRenderer createDefaultHeaderRenderer() 
{
        DefaultTableCellRenderer label = new DefaultTableCellRenderer() {
            public Component getTableCellRendererComponent(JTable table, Object value,
                         boolean isSelected, boolean hasFocus, int row, int column) {
                if (table != null) {
                    JTableHeader header = table.getTableHeader();
                    if (header != null) {
                        setForeground(header.getForeground());
                        setBackground(header.getBackground());
                        setFont(header.getFont());
                    }
                }
                setText((value == null) ? "" : value.toString());
                setBorder(UIManager.getBorder("TableHeader.cellBorder"));
                return this;
            }
        };
        label.setHorizontalAlignment(JLabel.CENTER);
        return label;
}

As of Java 2 platform v1.3, this method is not called by the TableColumn constructor. Previously this method was used by the TableColumn to create a default header renderer. As of Java 2 platform v1.3, the default header renderer is null. JTableHeader now provides its own shared default renderer, just as the JTable does for its cell renderers.

 public  void disableResizedPosting() 
{
        resizedPostingDisableCount++;
}

This field was not used in previous releases and there are currently no plans to support it in the future.

 public  void enableResizedPosting() 
{
        resizedPostingDisableCount--;
}

This field was not used in previous releases and there are currently no plans to support it in the future.

 public TableCellEditor getCellEditor() 
{
        return cellEditor;
}

Returns the TableCellEditor used by the JTable to edit values for this column. When the cellEditor is null, the JTable uses a default editor based on the class of the cells in that column. The default value for a cellEditor is null.

 public TableCellRenderer getCellRenderer() 
{
        return cellRenderer;
}

Returns the TableCellRenderer used by the JTable to draw values for this column. The cellRenderer of the column not only controls the visual look for the column, but is also used to interpret the value object supplied by the TableModel. When the cellRenderer is null, the JTable uses a default renderer based on the class of the cells in that column. The default value for a cellRenderer is null.

 public TableCellRenderer getHeaderRenderer() 
{
        return headerRenderer;
}

Returns the TableCellRenderer used to draw the header of the TableColumn. When the headerRenderer is null, the JTableHeader uses its defaultRenderer. The default value for a headerRenderer is null.

 public Object getHeaderValue() 
{
        return headerValue;
}

Returns the Object used as the value for the header renderer.

 public Object getIdentifier() 
{
        return (identifier != null) ? identifier : getHeaderValue();
}

Returns the identifier object for this column. Note identifiers are not used by JTable, they are purely a convenience for external use. If the identifier is null, getIdentifier() returns getHeaderValue as a default.

 public int getMaxWidth() 
{
        return maxWidth;
}

Returns the maximum width for the TableColumn. The TableColumn's width can't be made larger than this either by the user or programmatically. The default maxWidth is Integer.MAX_VALUE.

 public int getMinWidth() 
{
        return minWidth;
}

Returns the minimum width for the TableColumn. The TableColumn's width can't be made less than this either by the user or programmatically.

 public int getModelIndex() 
{
        return modelIndex;
}

Returns the model index for this column.

 public int getPreferredWidth() 
{
        return preferredWidth;
}

Returns the preferred width of the TableColumn. The default preferred width is 75.

 public synchronized PropertyChangeListener[] getPropertyChangeListeners() 
{
        if (changeSupport == null) {
            return new PropertyChangeListener[0];
        }
        return changeSupport.getPropertyChangeListeners();
}

Returns an array of all the PropertyChangeListeners added to this TableColumn with addPropertyChangeListener().

 public boolean getResizable() 
{
        return isResizable;
}

Returns true if the user is allowed to resize the TableColumn's width, false otherwise. You can change the width programmatically regardless of this setting. The default is true.

 public int getWidth() 
{
        return width;
}

Returns the width of the TableColumn. The default width is 75.

 public synchronized  void removePropertyChangeListener(PropertyChangeListener listener) 
{
        if (changeSupport != null) {
            changeSupport.removePropertyChangeListener(listener);
        }
}

Removes a PropertyChangeListener from the listener list. The PropertyChangeListener to be removed was registered for all properties.

 public  void setCellEditor(TableCellEditor cellEditor) 
{
        TableCellEditor old = this.cellEditor;
        this.cellEditor = cellEditor;
        firePropertyChange("cellEditor", old, cellEditor);
}

Sets the editor to used by when a cell in this column is edited.

 public  void setCellRenderer(TableCellRenderer cellRenderer) 
{
        TableCellRenderer old = this.cellRenderer;
        this.cellRenderer = cellRenderer;
        firePropertyChange("cellRenderer", old, cellRenderer);
}

Sets the TableCellRenderer used by JTable to draw individual values for this column.

 public  void setHeaderRenderer(TableCellRenderer headerRenderer) 
{
        TableCellRenderer old = this.headerRenderer;
        this.headerRenderer = headerRenderer;
        firePropertyChange("headerRenderer", old, headerRenderer);
}

Sets the TableCellRenderer used to draw the TableColumn's header to headerRenderer.

It is the header renderers responsibility to render the sorting indicator. If you are using sorting and specify a renderer your renderer must render the sorting indication.

 public  void setHeaderValue(Object headerValue) 
{
        Object old = this.headerValue;
        this.headerValue = headerValue;
        firePropertyChange("headerValue", old, headerValue);
}

Sets the Object whose string representation will be used as the value for the headerRenderer. When the TableColumn is created, the default headerValue is null.

 public  void setIdentifier(Object identifier) 
{
        Object old = this.identifier;
        this.identifier = identifier;
        firePropertyChange("identifier", old, identifier);
}

Sets the TableColumn's identifier to anIdentifier.

Note: identifiers are not used by the JTable, they are purely a convenience for the external tagging and location of columns.

 public  void setMaxWidth(int maxWidth) 
{
        int old = this.maxWidth;
        this.maxWidth = Math.max(minWidth, maxWidth);
        if (width  > this.maxWidth) {
            setWidth(this.maxWidth);
        }
        if (preferredWidth  > this.maxWidth) {
            setPreferredWidth(this.maxWidth);
        }
        firePropertyChange("maxWidth", old, this.maxWidth);
}

Sets the TableColumn's maximum width to maxWidth or, if maxWidth is less than the minimum width, to the minimum width.

If the value of the width or preferredWidth property is more than the new maximum width, this method sets that property to the new maximum width.

 public  void setMinWidth(int minWidth) 
{
        int old = this.minWidth;
        this.minWidth = Math.max(Math.min(minWidth, maxWidth), 0);
        if (width <  this.minWidth) {
            setWidth(this.minWidth);
        }
        if (preferredWidth <  this.minWidth) {
            setPreferredWidth(this.minWidth);
        }
        firePropertyChange("minWidth", old, this.minWidth);
}

Sets the TableColumn's minimum width to minWidth, adjusting the new minimum width if necessary to ensure that 0 <= minWidth <= maxWidth. For example, if the minWidth argument is negative, this method sets the minWidth property to 0.

If the value of the width or preferredWidth property is less than the new minimum width, this method sets that property to the new minimum width.

 public  void setModelIndex(int modelIndex) 
{
        int old = this.modelIndex;
        this.modelIndex = modelIndex;
        firePropertyChange("modelIndex", old, modelIndex);
}

Sets the model index for this column. The model index is the index of the column in the model that will be displayed by this TableColumn. As the TableColumn is moved around in the view the model index remains constant.

 public  void setPreferredWidth(int preferredWidth) 
{
        int old = this.preferredWidth;
        this.preferredWidth = Math.min(Math.max(preferredWidth, minWidth), maxWidth);
        firePropertyChange("preferredWidth", old, this.preferredWidth);
}

Sets this column's preferred width to preferredWidth. If preferredWidth exceeds the minimum or maximum width, it is adjusted to the appropriate limiting value.

For details on how the widths of columns in the JTable (and JTableHeader) are calculated from the preferredWidth, see the doLayout method in JTable.

 public  void setResizable(boolean isResizable) 
{
        boolean old = this.isResizable;
        this.isResizable = isResizable;
        firePropertyChange("isResizable", old, this.isResizable);
}

Sets whether this column can be resized.

 public  void setWidth(int width) 
{
        int old = this.width;
        this.width = Math.min(Math.max(width, minWidth), maxWidth);
        firePropertyChange("width", old, this.width);
}

This method should not be used to set the widths of columns in the JTable, use setPreferredWidth instead. Like a layout manager in the AWT, the JTable adjusts a column's width automatically whenever the table itself changes size, or a column's preferred width is changed. Setting widths programmatically therefore has no long term effect.

This method sets this column's width to width. If width exceeds the minimum or maximum width, it is adjusted to the appropriate limiting value.

 public  void sizeWidthToFit() 
{
        if (headerRenderer == null) {
            return;
        }
        Component c = headerRenderer.getTableCellRendererComponent(null,
                                getHeaderValue(), false, false, 0, 0);
        setMinWidth(c.getMinimumSize().width);
        setMaxWidth(c.getMaximumSize().width);
        setPreferredWidth(c.getPreferredSize().width);
        setWidth(getPreferredWidth());
}

Resizes the TableColumn to fit the width of its header cell. This method does nothing if the header renderer is null (the default case). Otherwise, it sets the minimum, maximum and preferred widths of this column to the widths of the minimum, maximum and preferred sizes of the Component delivered by the header renderer. The transient "width" property of this TableColumn is also set to the preferred width. Note this method is not used internally by the table package.