defaulttablemodel.java

gcc的组建

/* DefaultTableModel.java --
   Copyright (C) 2002, 2004, 2005,  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package javax.swing.table;

import java.io.Serializable;
import java.util.Vector;

import javax.swing.event.TableModelEvent;

/**
 * A two dimensional data structure used to store <code>Object</code> 
 * instances, usually for display in a <code>JTable</code> component.
 * 
 * @author	Andrew Selkirk
 */
public class DefaultTableModel extends AbstractTableModel
  implements Serializable
{
  static final long serialVersionUID = 6680042567037222321L;

  /**
   * Storage for the rows in the table (each row is itself 
   * a <code>Vector</code>).
   */
  protected Vector dataVector;

  /**
   * Storage for the column identifiers.
   */
  protected Vector columnIdentifiers;

  /**
   * Creates an empty table with zero rows and zero columns.
   */
  public DefaultTableModel() 
  {
    this(0, 0);
  }
  
  /**
   * Creates a new table with the specified number of rows and columns.
   * All cells in the table are initially empty (set to <code>null</code>).
   * 
   * @param numRows  the number of rows.
   * @param numColumns  the number of columns.
   */
  public DefaultTableModel(int numRows, int numColumns) 
  {
    Vector defaultNames = new Vector(numColumns);
    Vector data = new Vector(numRows);
    for (int i = 0; i < numColumns; i++) 
      {
        defaultNames.add(super.getColumnName(i));
      }          
    for (int r = 0; r < numRows; r++) 
      {
        Vector tmp = new Vector(numColumns);
        tmp.setSize(numColumns);
        data.add(tmp);
      }
    setDataVector(data, defaultNames);
  }
  
  /**
   * Creates a new table with the specified column names and number of
   * rows.  The number of columns is determined by the number of column
   * names supplied.
   *   
   * @param columnNames the column names.
   * @param numRows the number of rows.
   */
  public DefaultTableModel(Vector columnNames, int numRows) 
  {
    if (numRows < 0)
      throw new IllegalArgumentException("numRows < 0");
    Vector data = new Vector();
    int numColumns = 0;

    if (columnNames != null)
      numColumns = columnNames.size();
    
    while (0 < numRows--) 
      {
        Vector rowData = new Vector();
        rowData.setSize(numColumns);
        data.add(rowData);
      }
    setDataVector(data, columnNames);
  }

  /**
   * Creates a new table with the specified column names and row count.
   * 
   * @param columnNames the column names.
   * @param numRows the number of rows.
   */
  public DefaultTableModel(Object[] columnNames, int numRows) 
  {
    this(convertToVector(columnNames), numRows);
  }
  
  /**
   * Creates a new table with the specified data values and column names.
   * 
   * @param data the data values.
   * @param columnNames the column names.
   */
  public DefaultTableModel(Vector data, Vector columnNames) 
  {
    setDataVector(data, columnNames);
  }

  /**
   * Creates a new table with the specified data values and column names.
   * 
   * @param data the data values.
   * @param columnNames the column names.
   */
  public DefaultTableModel(Object[][] data, Object[] columnNames) 
  {
    this(convertToVector(data), convertToVector(columnNames));
  }

  /**
   * Returns the vector containing the row data for the table.
   * 
   * @return The data vector.
   */
  public Vector getDataVector() 
  {
    return dataVector;
  }

  /**
   * Sets the data and column identifiers for the table.  The data vector
   * contains a <code>Vector</code> for each row in the table - if the
   * number of objects in each row does not match the number of column
   * names specified, the row data is truncated or expanded (by adding
   * <code>null</code> values) as required.
   * 
   * @param data the data for the table (a vector of row vectors).
   * @param columnNames the column names.
   * 
   * @throws NullPointerException if either argument is <code>null</code>.
   */
  public void setDataVector(Vector data, Vector columnNames) 
  {
    if (data == null)
      dataVector = new Vector();
    else
      dataVector = data;
    setColumnIdentifiers(columnNames);
  }

  /**
   * Sets the data and column identifiers for the table.
   * 
   * @param data the data for the table.
   * @param columnNames the column names.
   * 
   * @throws NullPointerException if either argument is <code>null</code>.
   */
  public void setDataVector(Object[][] data, Object[] columnNames) 
  {
    setDataVector(convertToVector(data), 
                  convertToVector(columnNames));
  }
  
  /**
   * Sends the specified <code>event</code> to all registered listeners.
   * This method is equivalent to 
   * {@link AbstractTableModel#fireTableChanged(TableModelEvent)}.
   * 
   * @param event the event.
   */
  public void newDataAvailable(TableModelEvent event) 
  {
    fireTableChanged(event);
  }

  /**
   * Sends the specified <code>event</code> to all registered listeners.
   * This method is equivalent to 
   * {@link AbstractTableModel#fireTableChanged(TableModelEvent)}.
   * 
   * @param event the event.
   */
  public void newRowsAdded(TableModelEvent event) 
  {
    fireTableChanged(event);
  }

  /**
   * Sends the specified <code>event</code> to all registered listeners.
   * This method is equivalent to 
   * {@link AbstractTableModel#fireTableChanged(TableModelEvent)}.
   * 
   * @param event the event.
   */
  public void rowsRemoved(TableModelEvent event) 
  {
    fireTableChanged(event);
  }

  /**
   * Sets the column identifiers, updates the data rows (truncating
   * or padding each row with <code>null</code> values) to match the 
   * number of columns, and sends a {@link TableModelEvent} to all
   * registered listeners.
   * 
   * @param columnIdentifiers the column identifiers.
   */
  public void setColumnIdentifiers(Vector columnIdentifiers) 
  {
    this.columnIdentifiers = columnIdentifiers;
    setColumnCount((columnIdentifiers == null ? 0 : columnIdentifiers.size()));
  }
  
  /**
   * Sets the column identifiers, updates the data rows (truncating
   * or padding each row with <code>null</code> values) to match the 
   * number of columns, and sends a {@link TableModelEvent} to all
   * registered listeners.
   * 
   * @param columnIdentifiers the column identifiers.
   */
  public void setColumnIdentifiers(Object[] columnIdentifiers) 
  {
    setColumnIdentifiers(convertToVector(columnIdentifiers));
  }

  /**
   * This method is obsolete, use {@link #setRowCount(int)} instead.
   * 
   * @param numRows the number of rows.
   */
  public void setNumRows(int numRows) 
  {
    setRowCount(numRows);
  }

  /**
   * Sets the number of rows in the table.  If <code>rowCount</code> is less
   * than the current number of rows in the table, rows are discarded.
   * If <code>rowCount</code> is greater than the current number of rows in
   * the table, new (empty) rows are added.
   * 
   * @param rowCount the row count.
   */
  public void setRowCount(int rowCount) 
  {
    int existingRowCount = dataVector.size();
    if (rowCount < existingRowCount) 
    {
      dataVector.setSize(rowCount);
      fireTableRowsDeleted(rowCount,existingRowCount-1);      
    }
    else 
    {