/*
    * 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.beans.PropertyVetoException;
  import java.util.HashMap;
  import java.util.Map;
  
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.DataSource;
  import com.cosylab.gui.displayers.DataState;
  import com.cosylab.gui.displayers.DoubleConsumer;
  import com.cosylab.gui.displayers.LongConsumer;
  import com.cosylab.gui.displayers.NonblockingNumberConsumer;
  import com.cosylab.util.CommonException;
  
  public class OnApplyDispatcher extends DataConsumerDispatcher
  	implements DoubleConsumer, LongConsumer
  {
  	private static final long serialVersionUID = 1L;
  
  	// flag indicating if user has called cache characteristics
  	private boolean userCache = false;
  
  	// last dispatched characteristics, used to be redispatched
  	// when multiplication factor is changed or new consumer added
  	private Map lastCharacteristics;
  
  	// last dispatched data state, used to be redispatched when
  	// new consumer added
  	private DataState lastDataState;
  	
  	//private Map lastCharacteristics;
  	//private DataState lastDataState;
  	protected Number valueToSet = null;
  	private boolean onApply = true;
  	// dispatcher which intercepts feedback value from peer data consumer and dispatch it to peer data sources
  	private Dispatcher dispatcher;
  
  	class Dispatcher extends NonblockingNumberDispatcher
  	{
  		/*
  		    * @see com.cosylab.gui.adapters.NonblockingNumberDispatcher#updateNonblocking(java.lang.Number)
  		    */
  		public void updateNonblocking(Number value)
  		{
  			valueToSet = value;
  
  			if (!onApply) {
  				super.updateNonblocking(valueToSet);
  			}
  		}
  
  		/**
  		 * DOCUMENT ME!
  		 */
  		public void delegateUpdateNonblocking()
  		{
  			super.updateNonblocking(valueToSet);
  		}
  	}
  
  	/**
  	 * Creates a new OnApplyDispatcher object.
  	 */
  	public OnApplyDispatcher()
  	{
  		// we dalagate to super suppport class only the consumer type/types we want to suppport
  		super(new Class[]{ DoubleConsumer.class, LongConsumer.class });
  
  		// the name of this converter when it acts as a consumer
  		name = "OnApplyDispatcher";
  	}
  
  	protected NonblockingNumberDispatcher getNonblDisplatecher()
  	{
  		if (dispatcher == null) {
  			dispatcher = new Dispatcher();
  		}
  
  		return dispatcher;
  	}
 
 	/**
 	 * DOCUMENT ME!
 	 */
 	public void applyValue()
 	{
 		if (dispatcher != null) {
 			dispatcher.delegateUpdateNonblocking();
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public boolean isOnApply()
 	{
 		return onApply;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param onApply DOCUMENT ME!
 	 */
 	public void setOnApply(boolean onApply)
 	{
 		this.onApply = onApply;
 	}
 	/**
 	 * In this method we investigate the following cases:
 	 * 
 	 * <ul>
 	 * <li>
 	 * if consumer is <code>NonblockingNumberConsumer</code>, the it comes from
 	 * peer data source and wants to receive notifications from peer cosnumer
 	 * about user change requests.
 	 * </li>
 	 * <li>
 	 * if consumer is peer consumer and perhatps implements
 	 * <code>DataSource</code> interface. It it does, we must notify listener
 	 * for user data change requests.
 	 * </li>
 	 * </ul>
 	 * 
 	 *
 	 * @see com.cosylab.gui.displayers.DataSource#addConsumer(com.cosylab.gui.displayers.DataConsumer)
 	 */
 	public void addConsumer(DataConsumer consumer) throws PropertyVetoException
 	{
 		if (consumer instanceof NonblockingNumberConsumer) {
 			// this one comes from peer data source, to this one we delegate calls from peer data source
 			getNonblDisplatecher().addConsumer(consumer);
 
 			return;
 		}
 
 		super.addConsumer(consumer);
 
 		// new consumer did not receive characteristics or state, if converter
 		// already have already received them, they must be delegated
 		if (lastCharacteristics != null) {
 			consumer.setCharacteristics(lastCharacteristics);
 		}
 
 		if (lastDataState != null) {
 			consumer.updateDataState(lastDataState);
 		}
 
 		if (consumer instanceof DataSource) {
 			Class[] cl = ((DataSource)consumer).getAcceptableConsumerTypes();
 
 			for (int i = 0; i < cl.length; i++) {
 				if (cl[i].equals(NonblockingNumberConsumer.class)) {
 					/* here we reqister our nonblocking dispatcher, which dispatches
 					 * nonblocking requests to peer data source.
 					 */
 					((DataSource)consumer).addConsumer(getNonblDisplatecher());
 
 					return;
 				}
 			}
 		}
 	}
 	/**
 	 * If converter implementation decides to change characteristics it is very
 	 * advisable to cache unmodified characteristics. This chached
 	 * characteristics are used to initialized new consumers. They can be also
 	 * used by implementation to reinitialize consumers if transformation
 	 * function has changed.
 	 * 
 	 * <p>
 	 * If implementation does not change characteristic, than this method
 	 * doesen't have to be used.
 	 * </p>
 	 *
 	 * @param characteristics the unmodified characcteristics before
 	 *        transformation
 	 */
 	protected void cacheLastCharacteristics(Map characteristics)
 	{
 		lastCharacteristics = new HashMap(characteristics);
 		userCache = true;
 	}
 	public void clear()
 	{
 		getNonblDisplatecher().clear();
 
 		DataConsumer[] c = getConsumers();
 
 		for (int i = 0; i < c.length; i++) {
 			if (c[i] instanceof DataSource) {
 				((DataSource)c[i]).removeConsumer(getNonblDisplatecher());
 			}
 		}
 		
 		valueToSet = null;
 
 		super.clear();
 	}
 	/**
 	 * Returnes characcteristics whic was last time used on this data
 	 * converter. Use <code>cacheLastCharacteristics(Map)</code> to store
 	 * them.
 	 *
 	 * @return last used characcteristics from internal chache
 	 *
 	 * @see #cacheLastCharacteristics(Map)
 	 */
 	protected Map getLastCharacteristics()
 	{
 		return lastCharacteristics;
 	}
 	/**
 	 * This is called by peer data source. Call is delegated to contained
 	 * consumers. In the process it is modified with transformation function.
 	 *
 	 * @see com.cosylab.gui.displayers.DataConsumer#setCharacteristics(java.util.Map)
 	 */
 	public void setCharacteristics(Map characteristics)
 	{
 		if (!userCache) {
 			// We store in chache characteristic if implementation does not.
 			// We are assuming that user implementation did no changed them.
 			lastCharacteristics = new HashMap(characteristics);
 		}
 
 		super.setCharacteristics(characteristics);
 	}
 	/* (non-Javadoc)
    * @see com.cosylab.gui.displayers.DataConsumer#updateDataState(com.cosylab.gui.displayers.DataState)
    */
 public void updateDataState(DataState state)
 {
 lastDataState = state;
 super.updateDataState(state);
 }
 /**
  * This is called by peer data source. Call is delegated to contained
  * consumers.
  *
  * @see com.cosylab.gui.displayers.DoubleConsumer#updateValue(long, double)
  */
 public void updateValue(long timestamp, double value)
 	throws CommonException
 {
 
 	DataConsumer[] delegates = getConsumers();
 
 	// transform value
 	for (int i = 0; i < delegates.length; i++) {
 		try {
 			((DoubleConsumer)delegates[i]).updateValue(timestamp, value);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 }
 /**
  * This is called by peer data source. Call is delegated to contained
  * consumers.
  *
  * @see com.cosylab.gui.displayers.DoubleConsumer#updateValue(long, double)
  */
 public void updateValue(long timestamp, long value)
 	throws CommonException
 {
 
 	DataConsumer[] delegates = getConsumers();
 
 	// transform value
 	for (int i = 0; i < delegates.length; i++) {
 		try {
 			((LongConsumer)delegates[i]).updateValue(timestamp, value);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 }
 }
 
 /* __oOo__ */