/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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-Common 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-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.range2;
  
  import java.util.ArrayList;
  
  
  /**
   * <p>
   * RangedValue is used as pasive data representation, where each change to the
   * RangedValue is reported via RangedValueListener. This ensures centralized
   * handling of all changes and modifications.<br>
   * This is also the central class to be used when working with ranged value.
   * Typical use can be shown as:<br>
   * <code> class Example implements RangedValueListener {<br>
   * ...<br>
   * RangedValue value = new RangedValue();<br>
   * value.addRangeValueListener(this);<br>
   * value.addChangePolicy(new RescalingValuePolicy()); value.setRange(new
   * LogarithmicRange()); ... void valueChanged(RangedValueEvent event) { if
   * (event.minOrMaxChanged()) { // repaint scale } if (event.valueChanged()) {
   * // repaint value }}</code>
   * </p>
   * 
   * <p>
   * RangedValue will ensure that value vill always be consistant within min, max in range and
   * policies.
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @version $id$
   */
  public class RangedValueController 
  {
  	private Range range = null;
  	private double rawValue;
  	private final ArrayList<RangedValueListener> listeners = new ArrayList<RangedValueListener>();
  	private double scalingFactor=1.0;
  
  	private RangedValue rangedValue= new RangedValue();
  	private RangedValuePolicy policy;
  	
  	private TickCalculator tickCalculator = null;
  	private Tick[] lastTicksUsed = null;
  	private boolean snapToTicks = false;
  
  	/**
  	 * Creates default range implementation. Override this method to provide
  	 * different default implementation. By default, <code>LinearRange</code>
  	 * class is created.
  	 *
  	 * @return Range range Range interface implementation.
  	 */
  	protected Range createDefaultRange()
  	{
  		return new LinearRange();
  	}
  	/**
  	 * Returns current range definition.
  	 *
  	 * @see com.cosylab.gui.components.range2.RangedValueController#getRange()
  	 */
  	public Range getRange()
  	{
  		if (range == null) {
  			range = createDefaultRange();
  		}
  		return range;
  	}
  
  	/**
  	 * Sets the new definition of <code>Range</code>.
  	 *
  	 * @see com.cosylab.gui.components.range2.RangedValueController#setRange(Range)
  	 */
  	public void setRange(Range newRange)
  	{
  		// Save current range in case parameters cannot be adjusted to new
  		// range
  		range = newRange;
  
  		if (range != null) {
  			// Try tranferring the state
 			setRangedValue(new RangedValue(getMinimum(),getMaximum(),getRawValue()));
 		}
 	}
 	
 	/**
 	 * Sets the RangedValue to this controller.
 	 *  
 	 * @param v new ranged value
 	 */
 	public void setRangedValue(RangedValue v) {
 		if (snapToTicks && lastTicksUsed != null) {
 			final Tick[] ticks = lastTicksUsed;
 			double value = v.getValue();
 			for (int i = 1; i < ticks.length; i++) {
 				if (ticks[i-1].absolute == value) break;
 				if (ticks[i-1].absolute < value && ticks[i].absolute > value) {
 					if (ticks[i].absolute-value < value - ticks[i-1].absolute) {
 						value = ticks[i].absolute;
 					} else {
 						value = ticks[i-1].absolute;
 					}
 					break;
 				}
 			}
 			v = new RangedValue(v.getMinimum(), v.getMaximum(), value);
 		}
 		final double raw=v.getValue();
 		
 		// Make sure new values are valid in range
 		final Range r = getRange();
 		
 		v = new RangedValue(r.validate(v.getMinimum()),r.validate(v.getMaximum()), r.validate(v.getValue()));
 
 		// Apply policies
 		v = validatePolicies(v);
 
 		// Validate again if policieas has not moved ouside range
 		v = new RangedValue(r.validate(v.getMinimum()),r.validate(v.getMaximum()), r.validate(v.getValue()));
 		
 		// find out what has changed
 		boolean chMin = (getMinimum() != v.getMinimum());
 		boolean chMax = (getMaximum() != v.getMaximum());
 		boolean chVal = (getValue() != v.getValue());
 		
 		
 		if (chMin || chMax || chVal) {
 			rangedValue=new RangedValue(v.getMinimum(),v.getMaximum(),v.getValue());
 		}
 		
 		boolean chRaw= raw!=rawValue;
 		if (chRaw) {
 			rawValue=raw;
 		}
 		
 		
 		fireValueChange(chMin, chMax, chVal, chRaw);
 
 	}
 	
 	/**
 	 * Returns the RangedValue employed by this controller.
 	 * 
 	 * @return
 	 */
 	public RangedValue getRangedValue() {
 		if (rangedValue==null) {
 			rangedValue= new RangedValue();
 		}
 		return rangedValue;
 	}
 
 	/**
 	 * Returns current minimum the value can take. Depending on effective
 	 * policies, value could still be set below minimum.
 	 *
 	 * @return double current minimum.
 	 *
 	 * @see com.cosylab.gui.components.range2.RangedValueController#getMinimum()
 	 */
 	public double getMinimum()
 	{
 		return getRangedValue().getMinimum();
 	}
 
 	/**
 	 * Returns current maximum the value can take. Depending on effective
 	 * policies, value could still be set above maximum.
 	 *
 	 * @return double current maximum.
 	 *
 	 * @see com.cosylab.gui.components.range2.RangedValueController#getMaximum()
 	 */
 	public double getMaximum()
 	{
 		return getRangedValue().getMaximum();
 	}
 
 	/**
 	 * Returns current value.
 	 *
 	 * @return double current value.
 	 *
 	 * @see com.cosylab.gui.components.range2.RangedValueController#getValue()
 	 */
 	public double getValue()
 	{
 		return getRangedValue().getValue();
 	}
 
 	/**
 	 * Sets new value. This will attempt to set new value. If new value is
 	 * outside of range or policies are set, new value might not be the same
 	 * as the one set. Notification about this change will be reported via
 	 * RangedValueListener, where event can be queried about the actual  changes.<br>
 	 * setValue(double, double, double) should be called before using this
 	 * method for the first time to ensure the values. This is not neccessary
 	 * if no policies are in effect or values are known to conform to with
 	 * them.
 	 *
 	 * @see com.cosylab.gui.components.range2.RangedValueController#setValue()
 	 */
 	public void setValue(double value)
 	{
 		setValue(getMinimum(), getMaximum(), value);
 	}
 
 	/**
 	 * Sets new minimum. Setting the minimum may have side effects based on
 	 * range definition, policies and current value or maximum. Actual change
 	 * will be reported via RangedValueListener.<br>
 	 * setValue(double, double, double) should be called before using this
 	 * method for the first time to ensure the values. This is not neccessary
 	 * if no policies are in effect or values are known to conform to with
 	 * them.
 	 *
 	 * @param value double
 	 */
 	public void setMinimum(double value)
 	{
 		setValue(value, getMaximum(), getValue());
 	}
 
 	/**
 	 * Sets new maximum. Setting the maximum may have side effects based on
 	 * range definition, policies and current value or minimum. Actual change
 	 * will be reported via RangedValueListener.<br>
 	 * setValue(double, double, double) should be called before using this
 	 * method for the first time to ensure the values. This is not neccessary
 	 * if no policies are in effect or values are known to conform to with
 	 * them.
 	 *
 	 * @param value double
 	 */
 	public void setMaximum(double value)
 	{
 		setValue(getMinimum(), value, getValue());
 	}
 
 	/**
 	 * Checks all policies to give them oportunity to modify the values.
 	 *
 	 * @param values holder of values.
 	 */
 	public RangedValue validatePolicies(RangedValue values)
 	{
 
 		if (policy!=null) {
 			values = policy.validate(values);
 		}
 
 		// this is mandatory policy, keeps value visthin min/max.
 		return TrimValuePolicy.trim(values);
 
 	}
 
 	/**
 	 * Initializes all values to new values. Minimum, value and maximum should
 	 * be in this order when compared to each other.
 	 *
 	 * @param minimum double
 	 * @param maximum double
 	 * @param value double
 	 *
 	 * @throws InvalidBoundException In case the parameters do not conform with
 	 *         policies defined by this range.
 	 */
 	public synchronized void setValue(double minimum, double maximum,
 	    double value)
 	{
 		setRangedValue(new RangedValue(minimum,maximum,value));
 	}
 
 	/**
 	 * Notify listeners of the change.
 	 *
 	 * @param event
 	 */
 	protected void fireValueChange(RangedValueEvent event)
 	{
 		if (event == null) {
 			return;
 		}
 
 		synchronized (this) {
 			final int n = listeners.size();
 
 			for (int i = 0; i < n; i++) {
 				(listeners.get(i)).valueChanged(event);
 			}
 		}
 	}
 
 	protected void fireValueChange(boolean min, boolean max, boolean val, boolean raw)
 	{
 		if (min || max || val || raw) {
 			RangedValueEvent event = new RangedValueEvent(this, min, max, val, raw);
 			fireValueChange(event);
 		}
 	}
 
 	protected void firePolicyAdded()
 	{
 		fireValueChange(new RangedValueEvent(this, true));
 	}
 
 	protected void firePolicyRemoved()
 	{
 		fireValueChange(new RangedValueEvent(this, false));
 	}
 
 	/**
 	 * Adds new <code>RangedValuePolicy</code>. Polices will be checked in the
 	 * same order they are added.
 	 *
 	 * @see com.cosylab.gui.components.range2.RangedValueController#addChangePolicy(RangedValuePolicy)
 	 */
 	public synchronized void setPolicy(RangedValuePolicy policy)
 	{
 		this.policy= policy;
 
 		firePolicyAdded();
 	}
 
 	/**
 	 * Adds a RangedValueListener to the the controller. Listener is notified
 	 * of changes in the ranged value.
 	 * @param listener
 	 */
 	public void addRangedValueListener(RangedValueListener listener)
 	{
 		if (listener == null) {
 			return;
 		}
 
 		if (listeners.contains(listener)) {
 			return;
 		}
 
 		synchronized (listeners) {
 			listeners.add(listener);
 		}
 	}
 	
 	/**
 	 * Removes RangedValueListener from this controller.
 	 * 
 	 * @param listener
 	 */
 	public void removeRangedValueListener(RangedValueListener listener)
 	{
 		if (listener == null) {
 			return;
 		}
 
 		synchronized (listeners) {
 			listeners.remove(listener);
 		}
 	}
 
 	/**
 	 * Returns the relative value between min and max.
 	 * 
 	 * @return
 	 */
 	public synchronized double getRelativeValue()
 	{
 		if (scalingFactor==1.0) {
 			return getRange().toRelative(getValue(),getRangedValue());
 		}
 		return getRange().toRelative(getValue(),getRangedValue())*scalingFactor;
 	}
 
 	/**
 	 * Sets relative value according to min and max.
 	 * 
 	 * @param value new value
 	 */
 	public void setRelativeValue(double value)
 	{
 		if (scalingFactor==1.0) {
 			setValue(getRange().toAbsolute(value,getRangedValue()));
 		} else {
 			setValue(getRange().toAbsolute(value/scalingFactor,getRangedValue()));
 		}
 	}
 
 	/**
 	 * Returns the actual value.
 	 * 
 	 * @return
 	 */
 	public double getRawValue() {
 		return rawValue;
 	}
 	
 	/**
 	 * Validates the value according to the bounds and policies.
 	 * 
 	 * @param value value to be validated
 	 * 
 	 * @return validated value
 	 */
 	public double validate(double value) {
 		double v= getRange().validate(value);
 		RangedValue val= new RangedValue(getMinimum(),getMaximum(),v);
 		val = validatePolicies(val);
 		return val.getValue();
 	}
 
 	
 	/**
 	 * Returns the scalingFactor.
 	 * @return Returns the scalingFactor.
 	 */
 	public double getScalingFactor() {
 		return scalingFactor;
 	}
 
 	
 	/**
 	 * Sets new scalingFactor. Scaling factor scales relative value from 0 to 1.0 or whatever scaling factor is.
 	 * @param scalingFactor The scalingFactor to set.
 	 */
 	public void setScalingFactor(double scalingFactor) {
 		this.scalingFactor = scalingFactor;
 	}
 	
 	/**
 	 * Returns the currently employed policy.
 	 * 
 	 * @return
 	 */
 	public RangedValuePolicy getPolicy() {
 		return policy;
 	}
 	
 	/**
 	 * Adds a policy to this controller.
 	 * 
 	 * @param p
 	 */
 	public synchronized void addPolicy(RangedValuePolicy p) {
 		if (p==null) return;
 		
 		if (policy==null) {
 			policy=p;
 		} else {
 			policy.addPeerPolicy(p);
 		}
 
 		setRangedValue(new RangedValue(getMinimum(),getMaximum(),getRawValue()));
 		
 		firePolicyAdded();
 	}
 	
 	/**
 	 * Removes the policy from the controller.
 	 * 
 	 * @param p
 	 */
 	public void removePolicy(RangedValuePolicy p) {
 		if (p==null) {
 			return;
 		}
 		if (policy!=null) {
 			RangedValuePolicy pp= policy;
 			policy= policy.removePeerPolicy(p);
 			if (pp!=policy) {
 				setRangedValue(new RangedValue(getMinimum(),getMaximum(),getRawValue()));
 				firePolicyAdded();
 			}
 		}
 	}
 	
 	/**
 	 * Removes all policies of the given type.
 	 * 
 	 * @param c
 	 */
 	public void removePolicyByType(Class<? extends RangedValuePolicy> c) {
 		if (c==null) {
 			return;
 		}
 		if (policy!=null) {
 			RangedValuePolicy pp= policy;
 			policy= policy.removePeerPolicyByType(c);
 			if (pp!=policy) {
 				setRangedValue(new RangedValue(getMinimum(),getMaximum(),getRawValue()));
 				firePolicyAdded();
 			}
 		}
 	}
 	
 	/**
 	 * Converts the given value to the relative value according to the bounds.
 	 * 
 	 * @param d value to be converted
 	 * 
 	 * @return converted value
 	 */
 	public double toRelative(double d) {
 		if (scalingFactor==1.0) {
 			return getRange().toRelative(d,getRangedValue());
 		}
 		return getRange().toRelative(d, getRangedValue())*scalingFactor;
 	}
 
 	/**
 	 * Calculates ticks using the given measurer and width.
 	 * 
 	 * @param w
 	 * @param measurer
 	 * @return
 	 */
 	public Tick[] calculateTicks(int w, TickParameters measurer) {
 		if (tickCalculator != null) { 
 			lastTicksUsed = tickCalculator.calculateTicks(w, measurer, getRange(), getRangedValue());
 		} else {
 			lastTicksUsed = getRange().getDefaultTickCalculator().calculateTicks(w, measurer, getRange(), getRangedValue());
 		}
 		return lastTicksUsed;
 	}
 	
 	/**
 	 * Converts proportional value to the absolute.
 	 * 
 	 * @param proportional value to be converted
 	 * 
 	 * @return converted value
 	 */
 	public double toAbsolute(double proportional) {
 		if (scalingFactor==1.0) {
 			return getRange().toAbsolute(proportional,getRangedValue());
 		}
 		return getRange().toAbsolute(proportional/scalingFactor, getRangedValue());
 	}
 	
 	/**
 	 * Calculates ticks using default the given width and default measurer.
 	 * 
 	 * @param width
 	 * @return
 	 */
 	public Tick[] calculateTicks(int width) {
 		if (tickCalculator != null) {
 			lastTicksUsed = tickCalculator.calculateTicks(width, getRange(), getRangedValue());
 		} else {
 			lastTicksUsed = getRange().getDefaultTickCalculator().calculateTicks(width, getRange(), getRangedValue());
 		} 
 		return lastTicksUsed;
 	}
 	
 	/**
 	 * Sets the TickCalculator which overrides any default settings for this
 	 * controller. If this provider is non-null the controller should always
 	 * take this controller to calculate ticks.
 	 * 
 	 * @param provider
 	 */
 	public void setTickCalculator(TickCalculator calculator) {
 		this.tickCalculator = calculator;
 	}
 	
 	/**
 	 * Returns the ManualTickProvider which is used to calculated ticks for this
 	 * controller. If the provider is null the default settings are used, which
 	 * means that ticks calculation is delegated further to the Range.
 	 * 
 	 * @return
 	 */
 	public TickCalculator getTickCalculator() {
 		return this.tickCalculator;
 	}
 	
 	/**
 	 * Sets the snap to ticks property. If true the slider thumb can be moved on discrete
 	 * values defined by the slider ticks.
 	 * 
 	 * @param snapToTicks true if thumb should snap to ticks
 	 */
 	public void setSnapToTicks(boolean snapToTicks) {
 		if (this.snapToTicks == snapToTicks) return;
 		this.snapToTicks = snapToTicks;
 		setValue(getValue());
 	}
 	
 	/**
 	 * Returns true if snap to ticks is turned on.
 	 * 
 	 * @see #setSnapToTicks(boolean)
 	 * @return true if snap is turned on
 	 */
 	public boolean isSnapToTicks() {
 		return snapToTicks;
 	}
 	
 }
 
 /* __oOo__ */