/* ----------------------------------------------------------------------------
   The Kiwi Toolkit - A Java Class Library
   Copyright (C) 1998-2004 Mark A. Lindner

   This library 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 of the
   License, or (at your option) any later version.

   This library 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 this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.
 
   The author may be contacted at: mark_a_lindner@yahoo.com
   ----------------------------------------------------------------------------
   $Log: DomainObjectTableModel.java,v $
   Revision 1.7  2004/05/13 21:38:56  markl
   comment block updates

   Revision 1.6  2003/04/30 04:36:00  markl
   Fire model events as appropriate. Added updateObjectAt() method.

   Revision 1.5  2003/01/19 09:33:06  markl
   Javadoc & comment header updates.

   Revision 1.4  2001/03/12 04:11:42  markl
   Source code cleanup.

   Revision 1.3  1999/08/13 07:11:35  markl
   Added support for column widths.

   Revision 1.2  1999/07/25 13:41:44  markl
   Fixes and API additions.

   Revision 1.1  1999/07/16 07:11:22  markl
   Initial revision
   ----------------------------------------------------------------------------
*/

package kiwi.ui.model;

import java.sql.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;

import kiwi.db.*;
import kiwi.util.*;

/** A <code>TableModel</code> that may be used to display a (potentially
 * editable) list of persistent domain objects in a <code>JTable</code>.
 *
 * @author Mark Lindner
 *
 * @see kiwi.db.PersistentObject
 * @see kiwi.db.DomainObjectFieldAdapter
 */

public class DomainObjectTableModel extends AbstractTableModel
  {
  private DomainObjectFieldAdapter fieldAdapter;
  private Vector data;
  private boolean modified = false;
  private boolean deferredStore = false;
  private ExceptionHandler errorHandler = null;

  /** Construct a new <code>DomainObjectTableModel</code> for the given
   * field adapter.
   *
   * @param adapter The field adapter to use.
   */
  
  public DomainObjectTableModel(DomainObjectFieldAdapter adapter)
    {
    super();
    fieldAdapter = adapter;
    data = new Vector();
    }

  /** Set the <i>deferred store</i> mode for this model. If deferred store is
   * on (default), editing of a value in the model causes the corresponding
   * <code>PersistentObject</code> to be written to the persistent store
   * immediately via a call to its <code>store()</code> method. If deferred
   * store is off, no automatic stores are performed.
   *
   * @param flag A flag that specifies whether deferred mode should be on
   * (<code>true</code>) or off (<code>false</code>).
   */
  
  public void setDeferredStore(boolean flag)
    {
    deferredStore = flag;
    }

  /** Get the <i>deferred store</i> mode for this model.
   *
   * @return <code>true</code> if deferred store is on, and <code>false</code>
   * otherwise.
   */

  public boolean getDeferredStore()
    {
    return(deferredStore);
    }
  
  /** Get the name of a given column.
   *
   * @param column The index of the column.
   * @return The name of the field that corresponds to the given column.
   */
  
  public String getColumnName(int column)
    {
    return(fieldAdapter.getFieldName(column));
    }

  /** Add an object to the end of the data vector. A new row will be added
   * at the bottom of the table model.
   *
   * @param object The <code>PersistentObject</code> to add.
   */
  
  public void addObject(PersistentObject object)
    {
    int index = data.size();
    data.addElement(object);
    modified = true;

    fireTableRowsInserted(index, index);
    }

  /** Insert an object at the specified position in the data vector. A new row
   * will be inserted at the corresponding position in the table model.
   *
   * @param object The <code>PersistentObject</code> to add.
   * @param row The row at which to insert the object.
   */
  
  public void insertObjectAt(PersistentObject object, int row)
    {
    data.insertElementAt(object, row);
    modified = true;

    fireTableRowsInserted(row, row);
    }

  /** Notify the model that the object at the given row has been updated.
   *
   * @param row The row of the updated object.
   * @since Kiwi 1.4.2
   */

  public void updateObjectAt(int row)
    {
    if((row < 0) || (row >= data.size()))
      throw new IllegalArgumentException("Row out of bounds");

    fireTableRowsUpdated(row, row);
    }

  /** Remove all objects from the data vector. All rows will be removed from
   * the table model.
   */
  
  public void clear()
    {
    data.removeAllElements();
    modified = true;
    }

  /** Remove the object at the specified position from the data vector. The
   * row at the corresponding position in the table model will be removed.
   *
   * @param row The row of the object to remove.
   */
  
  public void removeObjectAt(int row)
    {
    data.removeElementAt(row);
    modified = true;

    fireTableRowsDeleted(row, row);
    }

  /** Get the row count for this model.
   *
   * @return The number of objects in the data vector (e.g., the number of
   * rows in the table model).
   */
  
  public int getRowCount()
    {
    return(data.size());
    }

  /** Get the column count for this model.
   *
   * @return The number of columns in this table model (e.g., the number of
   * fields as reported by the field adapter).
   */
  
  public int getColumnCount()
    {
    return(fieldAdapter.getFieldCount());
    }

  /** Get the value at the specified row and column in the table model.
   *
   * @param row The row.
   * @param column The column
   * @return The object at the specified coordinates.
   */
  
  public Object getValueAt(int row, int column)
    {
    PersistentObject object = (PersistentObject)data.elementAt(row);
    return(fieldAdapter.getField(object, column));
    }

  /** Set the value at the specified row and column in the table model.
   *
   * @param row The row.
   * @param column The column
   * @param value The new object for the specified coordinates.
   */
  
  public void setValueAt(Object value, int row, int column)
    {
    PersistentObject object = (PersistentObject)data.elementAt(row);
    try
      {
      fieldAdapter.setField(object, column, value);
      if(!deferredStore)
        object.store();
      modified = true;

      fireTableRowsUpdated(row, row);
      }
    catch(MutatorException ex)
      {
      _deliverException(ex);
      }
    catch(SQLException ex)
      {
      _deliverException(ex);
      }
    }

  /** Prepare a <code>JTable</code> for use with this model. This method
   * creates the necessary columns in the <code>JTable</code> and assigns
   * the appropriate cell renderers and editors (as provided by the field
   * adapter) for each column.
   *
   * @param table The <code>JTable</code> with which this model will be used.
   */
  
  public void prepareJTable(JTable table)
    {
    TableColumnModel cmodel = table.getColumnModel();
    int cols = cmodel.getColumnCount();

    for(int i = 0; i < cols; i++)
      {
      TableColumn tc = cmodel.getColumn(i);
      tc.setCellRenderer(fieldAdapter.getCellRenderer(i));
      tc.setCellEditor(fieldAdapter.getCellEditor(i));

      int w = fieldAdapter.getFieldPreferredWidth(i);
      if(w > 0)
        tc.setPreferredWidth(w);

      w = fieldAdapter.getFieldMinWidth(i);
      if(w > 0)
        tc.setMinWidth(w);

      w = fieldAdapter.getFieldMaxWidth(i);
      if(w > 0)
        tc.setMaxWidth(w);
      }
    }

  /** Get the <code>PersistentObject</code> for the specified row in the
   * table model.
   *
   * @param row The row.
   * @return The <code>PersistentObject</code> represented in the given row.
   * @see #getRowForObject
   */

  public PersistentObject getObjectForRow(int row)
    {
    return((PersistentObject)data.elementAt(row));
    }

  /** Get the row for the specified <code>PersistentObject</code>.
   *
   * @param object The <code>PersistentObject</code> to locate.
   * @return The row in the table model that represents the given object.
   * @see #getObjectForRow
   */
  
  public int getRowForObject(PersistentObject object)
    {
    return(data.indexOf(object));
    }

  /** Determine if the cell at the given coordinates is editable.
   *
   * @param row The row.
   * @param column The column.
   * @return <code>true</code> if the cell at the given row and column is
   * editable and <code>false</code> otherwise. The field adapter is consulted
   * to determine if the field corresponding to the given column is mutable.
   */

  public boolean isCellEditable(int row, int column)
    {
    return(fieldAdapter.isFieldEditable(column));
    }

  /** Determine if the data in this model has been modified.
   *
   * @return <code>true</code> if modifications have been made, and
   * <code>false</code> otherwise.
   *
   * @see #clearModified
   */
  
  public boolean isModified()
    {
    return(modified);
    }

  /** Clear the modification flag for this model.
   *
   * @see #isModified
   */
  
  public void clearModified()
    {
    modified = false;
    }

  /** Get the object type for the specified column.
   *
   * @param column The column.
   * @return A <code>Class</code> object for the specified column. This value
   * is ultimately obtained by calling the <code>getFieldClass()</code> method
   * of the field adapter.
   */
  
  public Class getColumnClass(int column)
    {
    return(fieldAdapter.getFieldClass(column));
    }

  /** Set the <code>ExceptionHandler</code> for this model. If an exception
   * occurs while a domain object is being updated as a result of a change
   * to one of the values in this model, the exception is caught and delivered
   * to the handler (if one is registered).
   *
   * @param handler The new (possibly <code>null</code>) exception handler.
   */
  
  public void setExceptionHandler(ExceptionHandler handler)
    {
    this.errorHandler = handler;
    }

  /** Get the current <code>ExceptionHandler</code> for this model.
   *
   * @return The current (possibly <code>null</code>) exception handler.
   */

  public ExceptionHandler getExceptionHandler()
    {
    return(errorHandler);
    }
  
  /* Deliver an exception to a handler, if one is registered. */

  private void _deliverException(Exception ex)
    {
    if(errorHandler != null)
      errorHandler.exceptionRaised(ex);
    }
  
  }

/* end of source file */