/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans.
    *
    * CosyBeans 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 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans 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 CosyBeans.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.adapters;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import com.cosylab.gui.displayers.CommonDisplayer;
  import com.cosylab.gui.displayers.DoubleConsumer;
  
  
  /**
   * <code>MulitplierConverter</code> acts as data source and data consumer in
   * the same time. This converter performas on all data flow  linear
   * transformation with user defined multiplication factor and shift. Value
   * transfirmation performs <code>x  multiplicationFactor + shift</code>.
   * 
   * <p>
   * <b>Note!</b> This implementation works only with data sources and consumers,
   * whcih support <code>double</code> as value type.
   * </p>
   *
   * @author <a href="mailto:igor.kriznar@cosylab.com">Igor Kriznar</a>
   * @version $Id: LinearConverter.java,v 1.16 2008-04-22 12:31:02 jbobnar Exp $
   *
   * @see com.cosylab.gui.adapters.Converter
   * @see com.cosylab.gui.adapters.SimpleConverterSupport
   * @since Feb 14, 2004.
   */
  @SuppressWarnings("unchecked")
  public class LinearConverter extends SimpleConverterSupport implements DoubleConsumer
  {
  
  	private static final long serialVersionUID = -9041321592219301979L;
  
  	public static final String SHORT_NAME = "Linear";
  	
  	// the multiplication factor
  	private double multiplicationFactor = 1.0;
  
  	// the the shift
  	private double shift = 0.0;
  
  	/**
  	 * Creates new multiplyer with default factor 1.0 and shift 0.0.
  	 */
  	public LinearConverter()
  	{
  		this(1.0, 0.0);
  	}
  
  	/**
  	 * Creates new multiplyer with defined factor and shift.
  	 *
  	 * @param factor new multiplicationfactor
  	 * @param shift new shift
  	 */
  	public LinearConverter(double factor, double shift)
  	{
  		// default value
  		setMultiplicationFactor(factor);
  		setShift(shift);
  
  		// the name of this converter when it acts as a consumer
  		name = "LinearConverter";
  	}
  
  	/**
  	 * This is called by peer data source. Call is delegated to contained
  	 * consumers. In the process it is modified with multiplication factor
  	 *
  	 * @see com.cosylab.gui.displayers.DataConsumer#setCharacteristics(java.util.Map)
  	 */
  	public void setCharacteristics(Map characteristics)
  	{
  		// we store unmodified characteristic for possible later reinitialization of 
  		// consumers, eg. if multiplication factor changes
  		cacheLastCharacteristics(characteristics);
  
  		HashMap map = new HashMap(characteristics);
  
  		double min;
 		double max;
 
 		if (map.containsKey(CommonDisplayer.C_GRAPH_MIN)
 		    && map.containsKey(CommonDisplayer.C_GRAPH_MAX)) {
 			min = ((Number)map.get(CommonDisplayer.C_GRAPH_MIN)).doubleValue();
 			max = ((Number)map.get(CommonDisplayer.C_GRAPH_MAX)).doubleValue();
 			
 			if (multiplicationFactor < 0) {
 				double a = max;
 				max = min;
 				min = a;
 			}
 			
 			map.put(CommonDisplayer.C_GRAPH_MIN, new Double(transform(min)));
 			map.put(CommonDisplayer.C_GRAPH_MAX, new Double(transform(max)));
 		}
 
 		if (map.containsKey(CommonDisplayer.C_MINIMUM)
 		    && map.containsKey(CommonDisplayer.C_MAXIMUM)) {
 			min = ((Number)map.get(CommonDisplayer.C_MINIMUM)).doubleValue();
 			max = ((Number)map.get(CommonDisplayer.C_MAXIMUM)).doubleValue();
 
 			if (multiplicationFactor < 0) {
 				double a = max;
 				max = min;
 				min = a;
 			}
 			
 			map.put(CommonDisplayer.C_MINIMUM, new Double(transform(min)));
 			map.put(CommonDisplayer.C_MAXIMUM, new Double(transform(max)));
 		}
 
 		map.put(CommonDisplayer.C_UNITS,
 			    "1/" + multiplicationFactor + "*" + map.get(CommonDisplayer.C_UNITS));
 
 		super.setCharacteristics(map);
 	}
 
 	/**
 	 * Returns factor by which all data from input will be multiplied
 	 *
 	 * @return multiplication factor
 	 */
 	public double getMultiplicationFactor()
 	{
 		return multiplicationFactor;
 	}
 
 	/**
 	 * Sets factor by which all data from input will be multiplied
 	 *
 	 * @param d new multiplication factor
 	 */
 	public void setMultiplicationFactor(double d)
 	{
 		multiplicationFactor = d;
 
 		if (getLastCharacteristics() != null) {
 			// reinitialize the peer consumers with changed multiplication factor
 			setCharacteristics(getLastCharacteristics());
 		}
 	}
 
 	/**
 	 * Here we implement our transformation function.
 	 *
 	 * @see com.cosylab.gui.adapters.SimpleConverterSupport#transform(double)
 	 */
 	protected double transform(double value)
 	{
 		return value * multiplicationFactor + shift;
 	}
 
 	/**
 	 * Here we implement invers transformation of our transformation function.
 	 *
 	 * @see com.cosylab.gui.adapters.SimpleConverterSupport#inverseTransform(double)
 	 */
 	protected double inverseTransform(double value)
 	{
 		return (value - shift) / multiplicationFactor;
 	}
 
 	/**
 	 * Returns the shift of transformed value.
 	 *
 	 * @return the shift of transformed value
 	 */
 	public double getShift()
 	{
 		return shift;
 	}
 
 	/**
 	 * Sets the shift of transformed value
 	 *
 	 * @param d new shift value
 	 */
 	public void setShift(double d)
 	{
 		shift = d;
 
 		if (getLastCharacteristics() != null) {
 			// reinitialize the peer consumers with changed shift
 			setCharacteristics(getLastCharacteristics());
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.adapters.DataConsumerDispatcher#getName()
 	 */
 	public String getName(){
 		return SHORT_NAME;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString(){
 		return SHORT_NAME + ": " + getMultiplicationFactor() + ", " + getShift();
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#equals(java.lang.Object)
 	 */
 	@Override
 	public boolean equals(Object obj) {
 		if (!(obj instanceof LinearConverter)) return false;
 		LinearConverter c = (LinearConverter)obj;
 		return c.getMultiplicationFactor() == multiplicationFactor && c.getShift() == shift;
 	}
 
 }
 
 /* __oOo__ */