You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
708 lines
24 KiB
708 lines
24 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package javax.swing.table;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.Vector;
|
|
import java.util.Enumeration;
|
|
import javax.swing.event.TableModelEvent;
|
|
|
|
|
|
/**
|
|
* This is an implementation of <code>TableModel</code> that
|
|
* uses a <code>Vector</code> of <code>Vectors</code> to store the
|
|
* cell value objects.
|
|
* <p>
|
|
* <strong>Warning:</strong> <code>DefaultTableModel</code> returns a
|
|
* column class of <code>Object</code>. When
|
|
* <code>DefaultTableModel</code> is used with a
|
|
* <code>TableRowSorter</code> this will result in extensive use of
|
|
* <code>toString</code>, which for non-<code>String</code> data types
|
|
* is expensive. If you use <code>DefaultTableModel</code> with a
|
|
* <code>TableRowSorter</code> you are strongly encouraged to override
|
|
* <code>getColumnClass</code> to return the appropriate type.
|
|
* <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 Philip Milne
|
|
*
|
|
* @see TableModel
|
|
* @see #getDataVector
|
|
*/
|
|
public class DefaultTableModel extends AbstractTableModel implements Serializable {
|
|
|
|
//
|
|
// Instance Variables
|
|
//
|
|
|
|
/**
|
|
* The <code>Vector</code> of <code>Vectors</code> of
|
|
* <code>Object</code> values.
|
|
*/
|
|
protected Vector dataVector;
|
|
|
|
/** The <code>Vector</code> of column identifiers. */
|
|
protected Vector columnIdentifiers;
|
|
|
|
//
|
|
// Constructors
|
|
//
|
|
|
|
/**
|
|
* Constructs a default <code>DefaultTableModel</code>
|
|
* which is a table of zero columns and zero rows.
|
|
*/
|
|
public DefaultTableModel() {
|
|
this(0, 0);
|
|
}
|
|
|
|
private static Vector newVector(int size) {
|
|
Vector v = new Vector(size);
|
|
v.setSize(size);
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>DefaultTableModel</code> with
|
|
* <code>rowCount</code> and <code>columnCount</code> of
|
|
* <code>null</code> object values.
|
|
*
|
|
* @param rowCount the number of rows the table holds
|
|
* @param columnCount the number of columns the table holds
|
|
*
|
|
* @see #setValueAt
|
|
*/
|
|
public DefaultTableModel(int rowCount, int columnCount) {
|
|
this(newVector(columnCount), rowCount);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>DefaultTableModel</code> with as many columns
|
|
* as there are elements in <code>columnNames</code>
|
|
* and <code>rowCount</code> of <code>null</code>
|
|
* object values. Each column's name will be taken from
|
|
* the <code>columnNames</code> vector.
|
|
*
|
|
* @param columnNames <code>vector</code> containing the names
|
|
* of the new columns; if this is
|
|
* <code>null</code> then the model has no columns
|
|
* @param rowCount the number of rows the table holds
|
|
* @see #setDataVector
|
|
* @see #setValueAt
|
|
*/
|
|
public DefaultTableModel(Vector columnNames, int rowCount) {
|
|
setDataVector(newVector(rowCount), columnNames);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>DefaultTableModel</code> with as many
|
|
* columns as there are elements in <code>columnNames</code>
|
|
* and <code>rowCount</code> of <code>null</code>
|
|
* object values. Each column's name will be taken from
|
|
* the <code>columnNames</code> array.
|
|
*
|
|
* @param columnNames <code>array</code> containing the names
|
|
* of the new columns; if this is
|
|
* <code>null</code> then the model has no columns
|
|
* @param rowCount the number of rows the table holds
|
|
* @see #setDataVector
|
|
* @see #setValueAt
|
|
*/
|
|
public DefaultTableModel(Object[] columnNames, int rowCount) {
|
|
this(convertToVector(columnNames), rowCount);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>DefaultTableModel</code> and initializes the table
|
|
* by passing <code>data</code> and <code>columnNames</code>
|
|
* to the <code>setDataVector</code> method.
|
|
*
|
|
* @param data the data of the table, a <code>Vector</code>
|
|
* of <code>Vector</code>s of <code>Object</code>
|
|
* values
|
|
* @param columnNames <code>vector</code> containing the names
|
|
* of the new columns
|
|
* @see #getDataVector
|
|
* @see #setDataVector
|
|
*/
|
|
public DefaultTableModel(Vector data, Vector columnNames) {
|
|
setDataVector(data, columnNames);
|
|
}
|
|
|
|
/**
|
|
* Constructs a <code>DefaultTableModel</code> and initializes the table
|
|
* by passing <code>data</code> and <code>columnNames</code>
|
|
* to the <code>setDataVector</code>
|
|
* method. The first index in the <code>Object[][]</code> array is
|
|
* the row index and the second is the column index.
|
|
*
|
|
* @param data the data of the table
|
|
* @param columnNames the names of the columns
|
|
* @see #getDataVector
|
|
* @see #setDataVector
|
|
*/
|
|
public DefaultTableModel(Object[][] data, Object[] columnNames) {
|
|
setDataVector(data, columnNames);
|
|
}
|
|
|
|
/**
|
|
* Returns the <code>Vector</code> of <code>Vectors</code>
|
|
* that contains the table's
|
|
* data values. The vectors contained in the outer vector are
|
|
* each a single row of values. In other words, to get to the cell
|
|
* at row 1, column 5: <p>
|
|
*
|
|
* <code>((Vector)getDataVector().elementAt(1)).elementAt(5);</code>
|
|
*
|
|
* @return the vector of vectors containing the tables data values
|
|
*
|
|
* @see #newDataAvailable
|
|
* @see #newRowsAdded
|
|
* @see #setDataVector
|
|
*/
|
|
public Vector getDataVector() {
|
|
return dataVector;
|
|
}
|
|
|
|
private static Vector nonNullVector(Vector v) {
|
|
return (v != null) ? v : new Vector();
|
|
}
|
|
|
|
/**
|
|
* Replaces the current <code>dataVector</code> instance variable
|
|
* with the new <code>Vector</code> of rows, <code>dataVector</code>.
|
|
* Each row is represented in <code>dataVector</code> as a
|
|
* <code>Vector</code> of <code>Object</code> values.
|
|
* <code>columnIdentifiers</code> are the names of the new
|
|
* columns. The first name in <code>columnIdentifiers</code> is
|
|
* mapped to column 0 in <code>dataVector</code>. Each row in
|
|
* <code>dataVector</code> is adjusted to match the number of
|
|
* columns in <code>columnIdentifiers</code>
|
|
* either by truncating the <code>Vector</code> if it is too long,
|
|
* or adding <code>null</code> values if it is too short.
|
|
* <p>Note that passing in a <code>null</code> value for
|
|
* <code>dataVector</code> results in unspecified behavior,
|
|
* an possibly an exception.
|
|
*
|
|
* @param dataVector the new data vector
|
|
* @param columnIdentifiers the names of the columns
|
|
* @see #getDataVector
|
|
*/
|
|
public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
|
|
this.dataVector = nonNullVector(dataVector);
|
|
this.columnIdentifiers = nonNullVector(columnIdentifiers);
|
|
justifyRows(0, getRowCount());
|
|
fireTableStructureChanged();
|
|
}
|
|
|
|
/**
|
|
* Replaces the value in the <code>dataVector</code> instance
|
|
* variable with the values in the array <code>dataVector</code>.
|
|
* The first index in the <code>Object[][]</code>
|
|
* array is the row index and the second is the column index.
|
|
* <code>columnIdentifiers</code> are the names of the new columns.
|
|
*
|
|
* @param dataVector the new data vector
|
|
* @param columnIdentifiers the names of the columns
|
|
* @see #setDataVector(Vector, Vector)
|
|
*/
|
|
public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
|
|
setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
|
|
}
|
|
|
|
/**
|
|
* Equivalent to <code>fireTableChanged</code>.
|
|
*
|
|
* @param event the change event
|
|
*
|
|
*/
|
|
public void newDataAvailable(TableModelEvent event) {
|
|
fireTableChanged(event);
|
|
}
|
|
|
|
//
|
|
// Manipulating rows
|
|
//
|
|
|
|
private void justifyRows(int from, int to) {
|
|
// Sometimes the DefaultTableModel is subclassed
|
|
// instead of the AbstractTableModel by mistake.
|
|
// Set the number of rows for the case when getRowCount
|
|
// is overridden.
|
|
dataVector.setSize(getRowCount());
|
|
|
|
for (int i = from; i < to; i++) {
|
|
if (dataVector.elementAt(i) == null) {
|
|
dataVector.setElementAt(new Vector(), i);
|
|
}
|
|
((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensures that the new rows have the correct number of columns.
|
|
* This is accomplished by using the <code>setSize</code> method in
|
|
* <code>Vector</code> which truncates vectors
|
|
* which are too long, and appends <code>null</code>s if they
|
|
* are too short.
|
|
* This method also sends out a <code>tableChanged</code>
|
|
* notification message to all the listeners.
|
|
*
|
|
* @param e this <code>TableModelEvent</code> describes
|
|
* where the rows were added.
|
|
* If <code>null</code> it assumes
|
|
* all the rows were newly added
|
|
* @see #getDataVector
|
|
*/
|
|
public void newRowsAdded(TableModelEvent e) {
|
|
justifyRows(e.getFirstRow(), e.getLastRow() + 1);
|
|
fireTableChanged(e);
|
|
}
|
|
|
|
/**
|
|
* Equivalent to <code>fireTableChanged</code>.
|
|
*
|
|
* @param event the change event
|
|
*
|
|
*/
|
|
public void rowsRemoved(TableModelEvent event) {
|
|
fireTableChanged(event);
|
|
}
|
|
|
|
/**
|
|
* Obsolete as of Java 2 platform v1.3. Please use <code>setRowCount</code> instead.
|
|
*/
|
|
/*
|
|
* Sets the number of rows in the model. If the new size is greater
|
|
* than the current size, new rows are added to the end of the model
|
|
* If the new size is less than the current size, all
|
|
* rows at index <code>rowCount</code> and greater are discarded.
|
|
*
|
|
* @param rowCount the new number of rows
|
|
* @see #setRowCount
|
|
*/
|
|
public void setNumRows(int rowCount) {
|
|
int old = getRowCount();
|
|
if (old == rowCount) {
|
|
return;
|
|
}
|
|
dataVector.setSize(rowCount);
|
|
if (rowCount <= old) {
|
|
fireTableRowsDeleted(rowCount, old-1);
|
|
}
|
|
else {
|
|
justifyRows(old, rowCount);
|
|
fireTableRowsInserted(old, rowCount-1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the number of rows in the model. If the new size is greater
|
|
* than the current size, new rows are added to the end of the model
|
|
* If the new size is less than the current size, all
|
|
* rows at index <code>rowCount</code> and greater are discarded.
|
|
*
|
|
* @see #setColumnCount
|
|
* @since 1.3
|
|
*/
|
|
public void setRowCount(int rowCount) {
|
|
setNumRows(rowCount);
|
|
}
|
|
|
|
/**
|
|
* Adds a row to the end of the model. The new row will contain
|
|
* <code>null</code> values unless <code>rowData</code> is specified.
|
|
* Notification of the row being added will be generated.
|
|
*
|
|
* @param rowData optional data of the row being added
|
|
*/
|
|
public void addRow(Vector rowData) {
|
|
insertRow(getRowCount(), rowData);
|
|
}
|
|
|
|
/**
|
|
* Adds a row to the end of the model. The new row will contain
|
|
* <code>null</code> values unless <code>rowData</code> is specified.
|
|
* Notification of the row being added will be generated.
|
|
*
|
|
* @param rowData optional data of the row being added
|
|
*/
|
|
public void addRow(Object[] rowData) {
|
|
addRow(convertToVector(rowData));
|
|
}
|
|
|
|
/**
|
|
* Inserts a row at <code>row</code> in the model. The new row
|
|
* will contain <code>null</code> values unless <code>rowData</code>
|
|
* is specified. Notification of the row being added will be generated.
|
|
*
|
|
* @param row the row index of the row to be inserted
|
|
* @param rowData optional data of the row being added
|
|
* @exception ArrayIndexOutOfBoundsException if the row was invalid
|
|
*/
|
|
public void insertRow(int row, Vector rowData) {
|
|
dataVector.insertElementAt(rowData, row);
|
|
justifyRows(row, row+1);
|
|
fireTableRowsInserted(row, row);
|
|
}
|
|
|
|
/**
|
|
* Inserts a row at <code>row</code> in the model. The new row
|
|
* will contain <code>null</code> values unless <code>rowData</code>
|
|
* is specified. Notification of the row being added will be generated.
|
|
*
|
|
* @param row the row index of the row to be inserted
|
|
* @param rowData optional data of the row being added
|
|
* @exception ArrayIndexOutOfBoundsException if the row was invalid
|
|
*/
|
|
public void insertRow(int row, Object[] rowData) {
|
|
insertRow(row, convertToVector(rowData));
|
|
}
|
|
|
|
private static int gcd(int i, int j) {
|
|
return (j == 0) ? i : gcd(j, i%j);
|
|
}
|
|
|
|
private static void rotate(Vector v, int a, int b, int shift) {
|
|
int size = b - a;
|
|
int r = size - shift;
|
|
int g = gcd(size, r);
|
|
for(int i = 0; i < g; i++) {
|
|
int to = i;
|
|
Object tmp = v.elementAt(a + to);
|
|
for(int from = (to + r) % size; from != i; from = (to + r) % size) {
|
|
v.setElementAt(v.elementAt(a + from), a + to);
|
|
to = from;
|
|
}
|
|
v.setElementAt(tmp, a + to);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Moves one or more rows from the inclusive range <code>start</code> to
|
|
* <code>end</code> to the <code>to</code> position in the model.
|
|
* After the move, the row that was at index <code>start</code>
|
|
* will be at index <code>to</code>.
|
|
* This method will send a <code>tableChanged</code> notification
|
|
message to all the listeners.
|
|
*
|
|
* <pre>
|
|
* Examples of moves:
|
|
*
|
|
* 1. moveRow(1,3,5);
|
|
* a|B|C|D|e|f|g|h|i|j|k - before
|
|
* a|e|f|g|h|B|C|D|i|j|k - after
|
|
*
|
|
* 2. moveRow(6,7,1);
|
|
* a|b|c|d|e|f|G|H|i|j|k - before
|
|
* a|G|H|b|c|d|e|f|i|j|k - after
|
|
* </pre>
|
|
*
|
|
* @param start the starting row index to be moved
|
|
* @param end the ending row index to be moved
|
|
* @param to the destination of the rows to be moved
|
|
* @exception ArrayIndexOutOfBoundsException if any of the elements
|
|
* would be moved out of the table's range
|
|
*
|
|
*/
|
|
public void moveRow(int start, int end, int to) {
|
|
int shift = to - start;
|
|
int first, last;
|
|
if (shift < 0) {
|
|
first = to;
|
|
last = end;
|
|
}
|
|
else {
|
|
first = start;
|
|
last = to + end - start;
|
|
}
|
|
rotate(dataVector, first, last + 1, shift);
|
|
|
|
fireTableRowsUpdated(first, last);
|
|
}
|
|
|
|
/**
|
|
* Removes the row at <code>row</code> from the model. Notification
|
|
* of the row being removed will be sent to all the listeners.
|
|
*
|
|
* @param row the row index of the row to be removed
|
|
* @exception ArrayIndexOutOfBoundsException if the row was invalid
|
|
*/
|
|
public void removeRow(int row) {
|
|
dataVector.removeElementAt(row);
|
|
fireTableRowsDeleted(row, row);
|
|
}
|
|
|
|
//
|
|
// Manipulating columns
|
|
//
|
|
|
|
/**
|
|
* Replaces the column identifiers in the model. If the number of
|
|
* <code>newIdentifier</code>s is greater than the current number
|
|
* of columns, new columns are added to the end of each row in the model.
|
|
* If the number of <code>newIdentifier</code>s is less than the current
|
|
* number of columns, all the extra columns at the end of a row are
|
|
* discarded.
|
|
*
|
|
* @param columnIdentifiers vector of column identifiers. If
|
|
* <code>null</code>, set the model
|
|
* to zero columns
|
|
* @see #setNumRows
|
|
*/
|
|
public void setColumnIdentifiers(Vector columnIdentifiers) {
|
|
setDataVector(dataVector, columnIdentifiers);
|
|
}
|
|
|
|
/**
|
|
* Replaces the column identifiers in the model. If the number of
|
|
* <code>newIdentifier</code>s is greater than the current number
|
|
* of columns, new columns are added to the end of each row in the model.
|
|
* If the number of <code>newIdentifier</code>s is less than the current
|
|
* number of columns, all the extra columns at the end of a row are
|
|
* discarded.
|
|
*
|
|
* @param newIdentifiers array of column identifiers.
|
|
* If <code>null</code>, set
|
|
* the model to zero columns
|
|
* @see #setNumRows
|
|
*/
|
|
public void setColumnIdentifiers(Object[] newIdentifiers) {
|
|
setColumnIdentifiers(convertToVector(newIdentifiers));
|
|
}
|
|
|
|
/**
|
|
* Sets the number of columns in the model. If the new size is greater
|
|
* than the current size, new columns are added to the end of the model
|
|
* with <code>null</code> cell values.
|
|
* If the new size is less than the current size, all columns at index
|
|
* <code>columnCount</code> and greater are discarded.
|
|
*
|
|
* @param columnCount the new number of columns in the model
|
|
*
|
|
* @see #setColumnCount
|
|
* @since 1.3
|
|
*/
|
|
public void setColumnCount(int columnCount) {
|
|
columnIdentifiers.setSize(columnCount);
|
|
justifyRows(0, getRowCount());
|
|
fireTableStructureChanged();
|
|
}
|
|
|
|
/**
|
|
* Adds a column to the model. The new column will have the
|
|
* identifier <code>columnName</code>, which may be null. This method
|
|
* will send a
|
|
* <code>tableChanged</code> notification message to all the listeners.
|
|
* This method is a cover for <code>addColumn(Object, Vector)</code> which
|
|
* uses <code>null</code> as the data vector.
|
|
*
|
|
* @param columnName the identifier of the column being added
|
|
*/
|
|
public void addColumn(Object columnName) {
|
|
addColumn(columnName, (Vector)null);
|
|
}
|
|
|
|
/**
|
|
* Adds a column to the model. The new column will have the
|
|
* identifier <code>columnName</code>, which may be null.
|
|
* <code>columnData</code> is the
|
|
* optional vector of data for the column. If it is <code>null</code>
|
|
* the column is filled with <code>null</code> values. Otherwise,
|
|
* the new data will be added to model starting with the first
|
|
* element going to row 0, etc. This method will send a
|
|
* <code>tableChanged</code> notification message to all the listeners.
|
|
*
|
|
* @param columnName the identifier of the column being added
|
|
* @param columnData optional data of the column being added
|
|
*/
|
|
public void addColumn(Object columnName, Vector columnData) {
|
|
columnIdentifiers.addElement(columnName);
|
|
if (columnData != null) {
|
|
int columnSize = columnData.size();
|
|
if (columnSize > getRowCount()) {
|
|
dataVector.setSize(columnSize);
|
|
}
|
|
justifyRows(0, getRowCount());
|
|
int newColumn = getColumnCount() - 1;
|
|
for(int i = 0; i < columnSize; i++) {
|
|
Vector row = (Vector)dataVector.elementAt(i);
|
|
row.setElementAt(columnData.elementAt(i), newColumn);
|
|
}
|
|
}
|
|
else {
|
|
justifyRows(0, getRowCount());
|
|
}
|
|
|
|
fireTableStructureChanged();
|
|
}
|
|
|
|
/**
|
|
* Adds a column to the model. The new column will have the
|
|
* identifier <code>columnName</code>. <code>columnData</code> is the
|
|
* optional array of data for the column. If it is <code>null</code>
|
|
* the column is filled with <code>null</code> values. Otherwise,
|
|
* the new data will be added to model starting with the first
|
|
* element going to row 0, etc. This method will send a
|
|
* <code>tableChanged</code> notification message to all the listeners.
|
|
*
|
|
* @see #addColumn(Object, Vector)
|
|
*/
|
|
public void addColumn(Object columnName, Object[] columnData) {
|
|
addColumn(columnName, convertToVector(columnData));
|
|
}
|
|
|
|
//
|
|
// Implementing the TableModel interface
|
|
//
|
|
|
|
/**
|
|
* Returns the number of rows in this data table.
|
|
* @return the number of rows in the model
|
|
*/
|
|
public int getRowCount() {
|
|
return dataVector.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the number of columns in this data table.
|
|
* @return the number of columns in the model
|
|
*/
|
|
public int getColumnCount() {
|
|
return columnIdentifiers.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the column name.
|
|
*
|
|
* @return a name for this column using the string value of the
|
|
* appropriate member in <code>columnIdentifiers</code>.
|
|
* If <code>columnIdentifiers</code> does not have an entry
|
|
* for this index, returns the default
|
|
* name provided by the superclass.
|
|
*/
|
|
public String getColumnName(int column) {
|
|
Object id = null;
|
|
// This test is to cover the case when
|
|
// getColumnCount has been subclassed by mistake ...
|
|
if (column < columnIdentifiers.size() && (column >= 0)) {
|
|
id = columnIdentifiers.elementAt(column);
|
|
}
|
|
return (id == null) ? super.getColumnName(column)
|
|
: id.toString();
|
|
}
|
|
|
|
/**
|
|
* Returns true regardless of parameter values.
|
|
*
|
|
* @param row the row whose value is to be queried
|
|
* @param column the column whose value is to be queried
|
|
* @return true
|
|
* @see #setValueAt
|
|
*/
|
|
public boolean isCellEditable(int row, int column) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns an attribute value for the cell at <code>row</code>
|
|
* and <code>column</code>.
|
|
*
|
|
* @param row the row whose value is to be queried
|
|
* @param column the column whose value is to be queried
|
|
* @return the value Object at the specified cell
|
|
* @exception ArrayIndexOutOfBoundsException if an invalid row or
|
|
* column was given
|
|
*/
|
|
public Object getValueAt(int row, int column) {
|
|
Vector rowVector = (Vector)dataVector.elementAt(row);
|
|
return rowVector.elementAt(column);
|
|
}
|
|
|
|
/**
|
|
* Sets the object value for the cell at <code>column</code> and
|
|
* <code>row</code>. <code>aValue</code> is the new value. This method
|
|
* will generate a <code>tableChanged</code> notification.
|
|
*
|
|
* @param aValue the new value; this can be null
|
|
* @param row the row whose value is to be changed
|
|
* @param column the column whose value is to be changed
|
|
* @exception ArrayIndexOutOfBoundsException if an invalid row or
|
|
* column was given
|
|
*/
|
|
public void setValueAt(Object aValue, int row, int column) {
|
|
Vector rowVector = (Vector)dataVector.elementAt(row);
|
|
rowVector.setElementAt(aValue, column);
|
|
fireTableCellUpdated(row, column);
|
|
}
|
|
|
|
//
|
|
// Protected Methods
|
|
//
|
|
|
|
/**
|
|
* Returns a vector that contains the same objects as the array.
|
|
* @param anArray the array to be converted
|
|
* @return the new vector; if <code>anArray</code> is <code>null</code>,
|
|
* returns <code>null</code>
|
|
*/
|
|
protected static Vector convertToVector(Object[] anArray) {
|
|
if (anArray == null) {
|
|
return null;
|
|
}
|
|
Vector<Object> v = new Vector<Object>(anArray.length);
|
|
for (Object o : anArray) {
|
|
v.addElement(o);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector of vectors that contains the same objects as the array.
|
|
* @param anArray the double array to be converted
|
|
* @return the new vector of vectors; if <code>anArray</code> is
|
|
* <code>null</code>, returns <code>null</code>
|
|
*/
|
|
protected static Vector convertToVector(Object[][] anArray) {
|
|
if (anArray == null) {
|
|
return null;
|
|
}
|
|
Vector<Vector> v = new Vector<Vector>(anArray.length);
|
|
for (Object[] o : anArray) {
|
|
v.addElement(convertToVector(o));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
} // End of class DefaultTableModel
|