/***
    * LayeredColorModel.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.colormodel;
  
  import java.awt.Color;
  import java.util.Vector;
  
  import org.jcreme.swing.table.TableColorModel;
  import org.jcreme.swing.table.TableColorModelEvent;
  import org.jcreme.swing.table.TableColorModelListener;
  
  /***
   * This class enables to layer color models. The first ColorModel is the top
   * layer. Each layer hides the layers underneath it.
   * 
   * @author $Author: dbregeon $
   * @version $Revision: 1.1 $
   */
  public class LayeredColorModel extends DefaultTableColorModel implements
          TableColorModel {
      /***
       * Hols the layers of TableColorModels.
       */
      private final Vector layers = new Vector();
  
      private final TableColorModelListener layersListener = new TableColorModelListener() {
          public void tableColorModelChanged(TableColorModelEvent e) {
              TableColorModelEvent forwardEvent = new TableColorModelEvent(
                      LayeredColorModel.this, e.getMinRow(), e.getMaxRow(), e
                              .getColumn());
              fireTableColorModelChanged(forwardEvent);
          }
  
      };
  
      /***
       * Enables to add a layer to the model.
       * 
       * @param layer
       *            the layer to add.
       */
      public void addLayer(TableColorModel layer) {
          if (layer != null) {
              synchronized (this.layers) {
                  this.layers.add(layer);
              }
              layer.addTableColorModelListener(this.layersListener);
          }
      }
  
      /***
       * Enables to add a layer to the model at a given depth.
       * 
       * @param layer
       *            the layer to add.
       * @param position
       *            the depth of the layer in the model.
       */
      public void setLayerAt(TableColorModel layer, int position) {
          if (layer != null) {
              synchronized (this.layers) {
                  if ((position >= 0) && (position < this.layers.size())) {
                      this.layers.insertElementAt(layer, position);
                  } else if (position >= this.layers.size()) {
                      addLayer(layer);
                  }
              }
              layer.addTableColorModelListener(this.layersListener);
  
          }
      }
  
      /***
       * Gives access to the layers that compose the model.
       * 
       * @return an array containing the layers by increasing depth.
      */
     public TableColorModel[] getLayers() {
         return (TableColorModel[]) this.layers.toArray(new TableColorModel[0]);
     }
 
     /***
      * Enables to remove a layer from the model.
      * 
      * @param layer
      *            the layer to remove.
      */
     public void removeLayer(TableColorModel layer) {
         if (layer != null) {
             layer.removeTableColorModelListener(this.layersListener);
             synchronized (this.layers) {
                 this.layers.removeElement(layer);
             }
         }
     }
 
     /***
      * Enables to remove the layer at a given depth from the model.
      * 
      * @param position
      *            the depth of the layer to remove.
      */
     public void removeLayerAt(int position) {
         if ((position >= 0) && (position < this.layers.size())) {
             TableColorModel layer = (TableColorModel) this.layers
                     .elementAt(position);
             layer.removeTableColorModelListener(this.layersListener);
             synchronized (this.layers) {
                 this.layers.removeElementAt(position);
             }
         }
     }
 
     /***
      * Gives access to the background color of a cell.
      * 
      * @param row
      *            the cell's row.
      * @param column
      *            the cell's column.
      * @param selected
      *            whether the cell is currently selected or not.
      * @param renderer
      *            the renderer used to display the cell.
      * @return the background color for the cell.
      */
     public Color getBackgroundColor(int row, int column, boolean selected,
             java.awt.Component renderer) {
         Color result = null;
         Color newColor = null;
         synchronized (this.layers) {
             // loop in reverse order so that the topmost color has
             // a stronger effect on the result.
             int index = this.layers.size();
             while ((result == null) && (index > 0)) {
                 index--;
                 result = ((TableColorModel) this.layers.elementAt(index))
                         .getBackgroundColor(row, column, selected, renderer);
             }
             while (index > 0) {
                 index--;
                 newColor = ((TableColorModel) this.layers.elementAt(index))
                         .getBackgroundColor(row, column, selected, renderer);
                 if (newColor != null) {
                     result = mixColors(newColor, result);
                 }
             }
         }
         return result;
     }
 
     /***
      * Gives access to the foreground color of a cell.
      * 
      * @param row
      *            the cell's row.
      * @param column
      *            the cell's column.
      * @param selected
      *            whether the cell is currently selected or not.
      * @param renderer
      *            the renderer used to display the cell.
      * @return the foreground color for the cell.
      */
     public Color getForegroundColor(int row, int column, boolean selected,
             java.awt.Component renderer) {
         Color newColor = null;
         Color result = null;
         synchronized (this.layers) {
             // loop in reverse order so that the topmost color has
             // a stronger effect on the result.
             int index = this.layers.size();
             while ((result == null) && (index > 0)) {
                 index--;
                 result = ((TableColorModel) this.layers.elementAt(index))
                         .getForegroundColor(row, column, selected, renderer);
             }
             while (index > 0) {
                 index--;
                 newColor = ((TableColorModel) this.layers.elementAt(index))
                         .getForegroundColor(row, column, selected, renderer);
                 if (newColor != null) {
                     result = mixColors(newColor, result);
                 }
             }
         }
         return result;
     }
 }