/***
    * JColoredTable.java
    *
    * This file is part of the creme library.
    * The creme library intends to ease the development effort of large
    * applications by providing easy to use support classes.
    *
    * Copyright (C) 2002 Denis Bregeon
    *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 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
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser 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
   *
   * contact information: dbregeon@sourceforge.net
   */
  package org.jcreme.swing.table;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Rectangle;
  import java.util.Vector;
  
  import javax.swing.JTable;
  import javax.swing.ListSelectionModel;
  import javax.swing.table.DefaultTableCellRenderer;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumnModel;
  import javax.swing.table.TableModel;
  
  /***
   * This subclass of JTable enable to implement a coloring scheme for the whole
   * table (not based on the renderers). The purpose is to provide a coloring
   * scheme that is consistent from the table point of view. A modification of the
   * renderers would have reduced the use to cell only color schemes. Instances of
   * this class should not be opaque.
   * 
   * @author $Author: dbregeon $
   * @version $Revision: 1.2 $
   */
  public class JColoredTable extends JTable implements TableColorModelListener {
  	/***
  	 * the color model used by this instance.
  	 */
  	private TableColorModel tableColorModel = null;
  
  	/***
  	 * Creates new JColoredTable.
  	 *  
  	 */
  	public JColoredTable() {
  		// Preserve the default constructor.
  	}
  
  	/***
  	 * Creates new JColoredTable
  	 * 
  	 * @param numRows
  	 *            the number of rows in the model.
  	 * @param numColumns
  	 *            the number of columns in the model.
  	 */
  	public JColoredTable(int numRows, int numColumns) {
  		super(numRows, numColumns);
  	}
  
  	/***
  	 * Creates new JColoredTable
  	 * 
  	 * @param rowData
  	 *            the values that compose the model.
  	 * @param columnNames
  	 *            the names of the columns of the model.
  	 */
  	public JColoredTable(Object[][] rowData, String[] columnNames) {
  		super(rowData, columnNames);
  	}
  
  	/***
  	 * Creates new JColoredTable
  	 * 
  	 * @param dm
  	 *            the underlying model.
  	 */
  	public JColoredTable(TableModel dm) {
  		super(dm);
  	}
  
  	/***
  	 * Creates new JColoredTable
 	 * 
 	 * @param dm
 	 *            the underlying model.
 	 * @param cm
 	 *            the column model.
 	 */
 	public JColoredTable(TableModel dm, TableColumnModel cm) {
 		super(dm, cm);
 	}
 
 	/***
 	 * Creates new JColoredTable
 	 * 
 	 * @param dm
 	 *            the underlying model.
 	 * @param cm
 	 *            the column model.
 	 * @param sm
 	 *            the selection model.
 	 */
 	public JColoredTable(TableModel dm, TableColumnModel cm,
 			ListSelectionModel sm) {
 		super(dm, cm, sm);
 	}
 
 	/***
 	 * Creates new JColoredTable
 	 * 
 	 * @param rowData
 	 *            the values that compose the model.
 	 * @param columnNames
 	 *            the names of the columns of the model.
 	 */
 	public JColoredTable(Vector rowData, Vector columnNames) {
 		super(rowData, columnNames);
 	}
 
 	/***
 	 * Sets the color model. The JColoredTable also becomes a listener of that
 	 * model.
 	 * 
 	 * @param model
 	 *            the color model that this table will use.
 	 */
 	public void setTableColorModel(TableColorModel model) {
 		TableColorModel oldValue = this.tableColorModel;
 		if (oldValue != null) {
 			oldValue.removeTableColorModelListener(this);
 			oldValue.setTableModel(null);
 		}
 		this.tableColorModel = model;
 		if (this.tableColorModel != null) {
 			this.tableColorModel.setTableModel(getModel());
 			// This is because of a line in the DefaultTableCellRenderer of
 			// JDK1.3 that ignores
 			// the background color when the table is opaque.
 			// It messes with the TableColorModels because we change the
 			// background color after the opacity of
 			// the renderer has been determined.
 			setOpaque(false);
 			this.tableColorModel.addTableColorModelListener(this);
 		} else {
 			setOpaque(true);
 		}
 		firePropertyChange("TableColorModel", oldValue, model);
 		repaint();
 	}
 
 	/***
 	 * This method gives access to the color model.
 	 * 
 	 * @return the current color model.
 	 */
 	public TableColorModel getTableColorModel() {
 		return this.tableColorModel;
 	}
 
 	/***
 	 * This is the method where the color scheme is applied. After the renderer
 	 * has been prepared, we change its color based on the values returned by
 	 * the color model of the table.
 	 * 
 	 * @param renderer
 	 *            the cell renderer.
 	 * @param row
 	 *            the cell row.
 	 * @param column
 	 *            the cell column.
 	 * @return the renderer for the given row and column.
 	 */
 	public Component prepareRenderer(TableCellRenderer renderer, int row,
 			int column) {
 		if (renderer instanceof DefaultTableCellRenderer) {
 			((DefaultTableCellRenderer) renderer).setBackground(null);
 			((DefaultTableCellRenderer) renderer).setForeground(null);
 		}
 		Component preparedRenderer = super.prepareRenderer(renderer, row,
 				column);
 		if (this.tableColorModel != null) {
 			Color color = this.tableColorModel.getBackgroundColor(row, column,
 					isCellSelected(row, column), preparedRenderer);
 			if (color != null) {
 				preparedRenderer.setBackground(color);
 			}
 			color = this.tableColorModel.getForegroundColor(row, column,
 					isCellSelected(row, column), preparedRenderer);
 			if (color != null) {
 				preparedRenderer.setForeground(color);
 			}
 		}
 		return preparedRenderer;
 	}
 
 	/***
 	 * This method is called when a TableColorModelEvent is received. It forces
 	 * the repaint of the parts of the table that are interested in the change.
 	 * 
 	 * @param event
 	 *            the event.
 	 */
 	public void tableColorModelChanged(TableColorModelEvent event) {
 		if ((event != null) && (event.getSource() == this.tableColorModel)) {
 			int minRow = 0;
 			int maxRow = getRowCount() - 1;
 			int minColumn = 0;
 			int maxColumn = getColumnCount() - 1;
 
 			if ((event.getMinRow() == TableColorModelEvent.ALL_ROWS)
 					&& (event.getColumn() == TableColorModelEvent.ALL_COLUMNS)) {
 				repaint();
 			} else {
 				if (event.getMinRow() != TableColorModelEvent.ALL_ROWS) {
 					minRow = event.getMinRow();
 					maxRow = event.getMaxRow();
 				}
 				if (event.getColumn() != TableColorModelEvent.ALL_COLUMNS) {
 					minColumn = event.getColumn();
 					maxColumn = minColumn;
 				}
 				Rectangle rect = new Rectangle();
 				for (int i = minRow; i < maxRow + 1; i++) {
 					for (int j = minColumn; j < maxColumn + 1; j++) {
 						rect.add(getCellRect(i, j, false));
 					}
 				}
 				repaint(rect);
 			}
 		}
 	}
 }