DefaultTableColumnModel.java

/*
 * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing.table;

importjavax.swing.*;
importjavax.swing.event.*;
importjava.awt.*;
importjava.util.Vector;
importjava.util.Enumeration;
importjava.util.EventListener;
importjava.beans.PropertyChangeListener;
importjava.beans.PropertyChangeEvent;
importjava.io.Serializable;
importsun.swing.SwingUtilities2;

/**
 * The standard column-handler for a <code>JTable</code>.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Alan Chung
 * @author Philip Milne
 * @see JTable
 */
@SuppressWarnings("serial") // Same-version serialization only
publicclassDefaultTableColumnModelimplementsTableColumnModel,
PropertyChangeListener, ListSelectionListener, Serializable
{
//
// Instance Variables
//

/** Array of TableColumn objects in this model */
protectedVector<TableColumn> tableColumns;

/** Model for keeping track of column selections */
protectedListSelectionModelselectionModel;

/** Width margin between each column */
protectedintcolumnMargin;

/** List of TableColumnModelListener */
protectedEventListenerListlistenerList = newEventListenerList();

/** Change event (only one needed) */
protectedtransientChangeEventchangeEvent = null;

/** Column selection allowed in this column model */
protectedbooleancolumnSelectionAllowed;

/** A local cache of the combined width of all columns */
protectedinttotalColumnWidth;

//
// Constructors
//
/**
 * Creates a default table column model.
 */
publicDefaultTableColumnModel() {
super();

// Initialize local ivars to default
tableColumns = newVector<TableColumn>();
setSelectionModel(createSelectionModel());
setColumnMargin(1);
invalidateWidthCache();
setColumnSelectionAllowed(false);
 }

//
// Modifying the model
//

/**
 * Appends <code>aColumn</code> to the end of the
 * <code>tableColumns</code> array.
 * This method also posts the <code>columnAdded</code>
 * event to its listeners.
 *
 * @param aColumn the <code>TableColumn</code> to be added
 * @throws IllegalArgumentException if <code>aColumn</code> is
 * <code>null</code>
 * @see #removeColumn
 */
publicvoidaddColumn(TableColumnaColumn) {
if (aColumn == null) {
thrownewIllegalArgumentException("Object is null");
 }

tableColumns.addElement(aColumn);
aColumn.addPropertyChangeListener(this);
invalidateWidthCache();

// Post columnAdded event notification
fireColumnAdded(newTableColumnModelEvent(this, 0,
getColumnCount() - 1));
 }

/**
 * Deletes the <code>column</code> from the
 * <code>tableColumns</code> array. This method will do nothing if
 * <code>column</code> is not in the table's columns list.
 * <code>tile</code> is called
 * to resize both the header and table views.
 * This method also posts a <code>columnRemoved</code>
 * event to its listeners.
 *
 * @param column the <code>TableColumn</code> to be removed
 * @see #addColumn
 */
publicvoidremoveColumn(TableColumncolumn) {
intcolumnIndex = tableColumns.indexOf(column);

if (columnIndex != -1) {
// Adjust for the selection
if (selectionModel != null) {
selectionModel.removeIndexInterval(columnIndex,columnIndex);
 }

column.removePropertyChangeListener(this);
tableColumns.removeElementAt(columnIndex);
invalidateWidthCache();

// Post columnAdded event notification. (JTable and JTableHeader
// listens so they can adjust size and redraw)
fireColumnRemoved(newTableColumnModelEvent(this,
columnIndex, 0));
 }
 }

/**
 * Moves the column and heading at <code>columnIndex</code> to
 * <code>newIndex</code>. The old column at <code>columnIndex</code>
 * will now be found at <code>newIndex</code>. The column
 * that used to be at <code>newIndex</code> is shifted
 * left or right to make room. This will not move any columns if
 * <code>columnIndex</code> equals <code>newIndex</code>. This method
 * also posts a <code>columnMoved</code> event to its listeners.
 *
 * @param columnIndex the index of column to be moved
 * @param newIndex new index to move the column
 * @throws IllegalArgumentException if <code>column</code> or
 * <code>newIndex</code>
 * are not in the valid range
 */
publicvoidmoveColumn(intcolumnIndex, intnewIndex) {
if ((columnIndex < 0) || (columnIndex >= getColumnCount()) ||
 (newIndex < 0) || (newIndex >= getColumnCount()))
thrownewIllegalArgumentException("moveColumn() - Index out of range");

TableColumnaColumn;

// If the column has not yet moved far enough to change positions
// post the event anyway, the "draggedDistance" property of the
// tableHeader will say how far the column has been dragged.
// Here we are really trying to get the best out of an
// API that could do with some rethinking. We preserve backward
// compatibility by slightly bending the meaning of these methods.
if (columnIndex == newIndex) {
fireColumnMoved(newTableColumnModelEvent(this, columnIndex, newIndex));
return;
 }
aColumn = tableColumns.elementAt(columnIndex);

tableColumns.removeElementAt(columnIndex);
booleanselected = selectionModel.isSelectedIndex(columnIndex);
selectionModel.removeIndexInterval(columnIndex,columnIndex);

tableColumns.insertElementAt(aColumn, newIndex);
selectionModel.insertIndexInterval(newIndex, 1, true);
if (selected) {
selectionModel.addSelectionInterval(newIndex, newIndex);
 }
else {
selectionModel.removeSelectionInterval(newIndex, newIndex);
 }

fireColumnMoved(newTableColumnModelEvent(this, columnIndex,
newIndex));
 }

/**
 * Sets the column margin to <code>newMargin</code>. This method
 * also posts a <code>columnMarginChanged</code> event to its
 * listeners.
 *
 * @param newMargin the new margin width, in pixels
 * @see #getColumnMargin
 * @see #getTotalColumnWidth
 */
publicvoidsetColumnMargin(intnewMargin) {
if (newMargin != columnMargin) {
columnMargin = newMargin;
// Post columnMarginChanged event notification.
fireColumnMarginChanged();
 }
 }

//
// Querying the model
//

/**
 * Returns the number of columns in the <code>tableColumns</code> array.
 *
 * @return the number of columns in the <code>tableColumns</code> array
 * @see #getColumns
 */
publicintgetColumnCount() {
returntableColumns.size();
 }

/**
 * Returns an <code>Enumeration</code> of all the columns in the model.
 * @return an <code>Enumeration</code> of the columns in the model
 */
publicEnumeration<TableColumn> getColumns() {
returntableColumns.elements();
 }

/**
 * Returns the index of the first column in the <code>tableColumns</code>
 * array whose identifier is equal to <code>identifier</code>,
 * when compared using <code>equals</code>.
 *
 * @param identifier the identifier object
 * @return the index of the first column in the
 * <code>tableColumns</code> array whose identifier
 * is equal to <code>identifier</code>
 * @throws IllegalArgumentException if <code>identifier</code>
 * is <code>null</code>, or if no
 * <code>TableColumn</code> has this
 * <code>identifier</code>
 * @see #getColumn
 */
publicintgetColumnIndex(Objectidentifier) {
if (identifier == null) {
thrownewIllegalArgumentException("Identifier is null");
 }

Enumeration<TableColumn> enumeration = getColumns();
TableColumnaColumn;
intindex = 0;

while (enumeration.hasMoreElements()) {
aColumn = enumeration.nextElement();
// Compare them this way in case the column's identifier is null.
if (identifier.equals(aColumn.getIdentifier()))
returnindex;
index++;
 }
thrownewIllegalArgumentException("Identifier not found");
 }

/**
 * Returns the <code>TableColumn</code> object for the column
 * at <code>columnIndex</code>.
 *
 * @param columnIndex the index of the column desired
 * @return the <code>TableColumn</code> object for the column
 * at <code>columnIndex</code>
 * @throws ArrayIndexOutOfBoundsException if <code>columnIndex</code>
 * is out of range:
 * (<code>columnIndex &lt; 0 || columnIndex &gt;= getColumnCount()</code>)
 */
publicTableColumngetColumn(intcolumnIndex) {
returntableColumns.elementAt(columnIndex);
 }

/**
 * Returns the width margin for <code>TableColumn</code>.
 * The default <code>columnMargin</code> is 1.
 *
 * @return the maximum width for the <code>TableColumn</code>
 * @see #setColumnMargin
 */
publicintgetColumnMargin() {
returncolumnMargin;
 }

/**
 * Returns the index of the column that lies at position <code>x</code>,
 * or -1 if no column covers this point.
 *
 * In keeping with Swing's separable model architecture, a
 * TableColumnModel does not know how the table columns actually appear on
 * screen. The visual presentation of the columns is the responsibility
 * of the view/controller object using this model (typically JTable). The
 * view/controller need not display the columns sequentially from left to
 * right. For example, columns could be displayed from right to left to
 * accommodate a locale preference or some columns might be hidden at the
 * request of the user. Because the model does not know how the columns
 * are laid out on screen, the given <code>xPosition</code> should not be
 * considered to be a coordinate in 2D graphics space. Instead, it should
 * be considered to be a width from the start of the first column in the
 * model. If the column index for a given X coordinate in 2D space is
 * required, <code>JTable.columnAtPoint</code> can be used instead.
 *
 * @param x the horizontal location of interest
 * @return the index of the column or -1 if no column is found
 * @see javax.swing.JTable#columnAtPoint
 */
publicintgetColumnIndexAtX(intx) {
if (x < 0) {
return -1;
 }
intcc = getColumnCount();
for(intcolumn = 0; column < cc; column++) {
x = x - getColumn(column).getWidth();
if (x < 0) {
returncolumn;
 }
 }
return -1;
 }

/**
 * Returns the total combined width of all columns.
 * @return the <code>totalColumnWidth</code> property
 */
publicintgetTotalColumnWidth() {
if (totalColumnWidth == -1) {
recalcWidthCache();
 }
returntotalColumnWidth;
 }

//
// Selection model
//

/**
 * Sets the selection model for this <code>TableColumnModel</code>
 * to <code>newModel</code>
 * and registers for listener notifications from the new selection
 * model. If <code>newModel</code> is <code>null</code>,
 * an exception is thrown.
 *
 * @param newModel the new selection model
 * @throws IllegalArgumentException if <code>newModel</code>
 * is <code>null</code>
 * @see #getSelectionModel
 */
publicvoidsetSelectionModel(ListSelectionModelnewModel) {
if (newModel == null) {
thrownewIllegalArgumentException("Cannot set a null SelectionModel");
 }

ListSelectionModeloldModel = selectionModel;

if (newModel != oldModel) {
if (oldModel != null) {
oldModel.removeListSelectionListener(this);
 }

selectionModel= newModel;
newModel.addListSelectionListener(this);
 }
 }

/**
 * Returns the <code>ListSelectionModel</code> that is used to
 * maintain column selection state.
 *
 * @return the object that provides column selection state. Or
 * <code>null</code> if row selection is not allowed.
 * @see #setSelectionModel
 */
publicListSelectionModelgetSelectionModel() {
returnselectionModel;
 }

// implements javax.swing.table.TableColumnModel
/**
 * Sets whether column selection is allowed. The default is false.
 * @param flag true if column selection will be allowed, false otherwise
 */
publicvoidsetColumnSelectionAllowed(booleanflag) {
columnSelectionAllowed = flag;
 }

// implements javax.swing.table.TableColumnModel
/**
 * Returns true if column selection is allowed, otherwise false.
 * The default is false.
 * @return the <code>columnSelectionAllowed</code> property
 */
publicbooleangetColumnSelectionAllowed() {
returncolumnSelectionAllowed;
 }

// implements javax.swing.table.TableColumnModel
/**
 * Returns an array of selected columns. If <code>selectionModel</code>
 * is <code>null</code>, returns an empty array.
 * @return an array of selected columns or an empty array if nothing
 * is selected or the <code>selectionModel</code> is
 * <code>null</code>
 */
publicint[] getSelectedColumns() {
if (selectionModel != null) {
returnselectionModel.getSelectedIndices();
 }
returnnewint[0];
 }

// implements javax.swing.table.TableColumnModel
/**
 * Returns the number of columns selected.
 * @return the number of columns selected
 */
publicintgetSelectedColumnCount() {
if (selectionModel != null) {
returnselectionModel.getSelectedItemsCount();
 }
return0;
 }

//
// Listener Support Methods
//

// implements javax.swing.table.TableColumnModel
/**
 * Adds a listener for table column model events.
 * @param x a <code>TableColumnModelListener</code> object
 */
publicvoidaddColumnModelListener(TableColumnModelListenerx) {
listenerList.add(TableColumnModelListener.class, x);
 }

// implements javax.swing.table.TableColumnModel
/**
 * Removes a listener for table column model events.
 * @param x a <code>TableColumnModelListener</code> object
 */
publicvoidremoveColumnModelListener(TableColumnModelListenerx) {
listenerList.remove(TableColumnModelListener.class, x);
 }

/**
 * Returns an array of all the column model listeners
 * registered on this model.
 *
 * @return all of this default table column model's <code>ColumnModelListener</code>s
 * or an empty
 * array if no column model listeners are currently registered
 *
 * @see #addColumnModelListener
 * @see #removeColumnModelListener
 *
 * @since 1.4
 */
publicTableColumnModelListener[] getColumnModelListeners() {
returnlistenerList.getListeners(TableColumnModelListener.class);
 }

//
// Event firing methods
//

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type. The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param e the event received
 * @see EventListenerList
 */
protectedvoidfireColumnAdded(TableColumnModelEvente) {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (inti = listeners.length-2; i>=0; i-=2) {
if (listeners[i]==TableColumnModelListener.class) {
// Lazily create the event:
// if (e == null)
// e = new ChangeEvent(this);
 ((TableColumnModelListener)listeners[i+1]).
columnAdded(e);
 }
 }
 }

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type. The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param e the event received
 * @see EventListenerList
 */
protectedvoidfireColumnRemoved(TableColumnModelEvente) {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (inti = listeners.length-2; i>=0; i-=2) {
if (listeners[i]==TableColumnModelListener.class) {
// Lazily create the event:
// if (e == null)
// e = new ChangeEvent(this);
 ((TableColumnModelListener)listeners[i+1]).
columnRemoved(e);
 }
 }
 }

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type. The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param e the event received
 * @see EventListenerList
 */
protectedvoidfireColumnMoved(TableColumnModelEvente) {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (inti = listeners.length-2; i>=0; i-=2) {
if (listeners[i]==TableColumnModelListener.class) {
// Lazily create the event:
// if (e == null)
// e = new ChangeEvent(this);
 ((TableColumnModelListener)listeners[i+1]).
columnMoved(e);
 }
 }
 }

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type. The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @param e the event received
 * @see EventListenerList
 */
protectedvoidfireColumnSelectionChanged(ListSelectionEvente) {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (inti = listeners.length-2; i>=0; i-=2) {
if (listeners[i]==TableColumnModelListener.class) {
// Lazily create the event:
// if (e == null)
// e = new ChangeEvent(this);
 ((TableColumnModelListener)listeners[i+1]).
columnSelectionChanged(e);
 }
 }
 }

/**
 * Notifies all listeners that have registered interest for
 * notification on this event type. The event instance
 * is lazily created using the parameters passed into
 * the fire method.
 * @see EventListenerList
 */
protectedvoidfireColumnMarginChanged() {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (inti = listeners.length-2; i>=0; i-=2) {
if (listeners[i]==TableColumnModelListener.class) {
// Lazily create the event:
if (changeEvent == null)
changeEvent = newChangeEvent(this);
 ((TableColumnModelListener)listeners[i+1]).
columnMarginChanged(changeEvent);
 }
 }
 }

/**
 * Returns an array of all the objects currently registered
 * as <code><em>Foo</em>Listener</code>s
 * upon this model.
 * <code><em>Foo</em>Listener</code>s are registered using the
 * <code>add<em>Foo</em>Listener</code> method.
 *
 * <p>
 *
 * You can specify the <code>listenerType</code> argument
 * with a class literal,
 * such as
 * <code><em>Foo</em>Listener.class</code>.
 * For example, you can query a
 * <code>DefaultTableColumnModel</code> <code>m</code>
 * for its column model listeners with the following code:
 *
 * <pre>ColumnModelListener[] cmls = (ColumnModelListener[])(m.getListeners(ColumnModelListener.class));</pre>
 *
 * If no such listeners exist, this method returns an empty array.
 *
 * @param <T> the listener type
 * @param listenerType the type of listeners requested
 * @return an array of all objects registered as
 * <code><em>Foo</em>Listener</code>s on this model,
 * or an empty array if no such
 * listeners have been added
 * @throws ClassCastException if <code>listenerType</code>
 * doesn't specify a class or interface that implements
 * <code>java.util.EventListener</code>
 *
 * @see #getColumnModelListeners
 * @since 1.3
 */
public <TextendsEventListener> T[] getListeners(Class<T> listenerType) {
returnlistenerList.getListeners(listenerType);
 }

//
// Implementing the PropertyChangeListener interface
//

// PENDING(alan)
// implements java.beans.PropertyChangeListener
/**
 * Property Change Listener change method. Used to track changes
 * to the column width or preferred column width.
 *
 * @param evt <code>PropertyChangeEvent</code>
 */
publicvoidpropertyChange(PropertyChangeEventevt) {
Stringname = evt.getPropertyName();

if (name == "width" || name == "preferredWidth") {
invalidateWidthCache();
// This is a misnomer, we're using this method
// simply to cause a relayout.
fireColumnMarginChanged();
 }

 }

//
// Implementing ListSelectionListener interface
//

// implements javax.swing.event.ListSelectionListener
/**
 * A <code>ListSelectionListener</code> that forwards
 * <code>ListSelectionEvents</code> when there is a column
 * selection change.
 *
 * @param e the change event
 */
publicvoidvalueChanged(ListSelectionEvente) {
fireColumnSelectionChanged(e);
 }

//
// Protected Methods
//

/**
 * Creates a new default list selection model.
 *
 * @return a newly created default list selection model.
 */
protectedListSelectionModelcreateSelectionModel() {
returnnewDefaultListSelectionModel();
 }

/**
 * Recalculates the total combined width of all columns. Updates the
 * <code>totalColumnWidth</code> property.
 */
protectedvoidrecalcWidthCache() {
Enumeration<TableColumn> enumeration = getColumns();
totalColumnWidth = 0;
while (enumeration.hasMoreElements()) {
totalColumnWidth += enumeration.nextElement().getWidth();
 }
 }

privatevoidinvalidateWidthCache() {
totalColumnWidth = -1;
 }

} // End of class DefaultTableColumnModel