/*
    * 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;
  
  import java.awt.event.ActionEvent;
  import java.beans.PropertyVetoException;
  import java.util.Map;
  
  import javax.swing.AbstractAction;
  
  import com.cosylab.application.state.State;
  import com.cosylab.events.SetEvent;
  import com.cosylab.events.SetListener;
  import com.cosylab.gui.adapters.Converter;
  import com.cosylab.gui.components.AbstractDisplayerPanel;
  import com.cosylab.gui.components.LabelledNumberField;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.RunnerHelper;
  import com.cosylab.gui.displayers.ConvertibleDisplayer;
  import com.cosylab.gui.displayers.DataConsumer;
  import com.cosylab.gui.displayers.DataSource;
  import com.cosylab.gui.displayers.DataSourceSupport;
  import com.cosylab.gui.displayers.DataState;
  import com.cosylab.gui.displayers.DisplayerUtilities;
  import com.cosylab.gui.displayers.DoubleConsumer;
  import com.cosylab.gui.displayers.DoubleConsumerMulticaster;
  import com.cosylab.gui.displayers.DoubleDisplayer;
  import com.cosylab.gui.displayers.NonblockingNumberConsumer;
  
  
  /**
   * <code>DoubleNumberDisplayer</code> is simple implementation of
   * <code>DoubleDisplayer</code> interface based on
   * <code>LabelledNumberfield</code>.
   *
   * @author <a href="mailto:igor.kriznar@cosylab.com">Igor Kriznar</a>
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $Id: DoubleNumberDisplayer.java,v 1.16 2008-04-22 12:31:02 jbobnar Exp $
   *
   * @since Nov 24, 2003.
   */
  public class DoubleNumberDisplayer extends LabelledNumberField
  	implements DoubleDisplayer, DataSource, ConvertibleDisplayer
  {
  	private static final long serialVersionUID = 1L;
  
  	public static void main(String[] args) {
  		DoubleNumberDisplayer disp = new DoubleNumberDisplayer();
  		disp.setPopupEnabled(false);
  		RunnerHelper.runComponent(disp, 300,300);
  	}
  	@SuppressWarnings("unchecked")
  	private DataSourceSupport support = new DataSourceSupport(new Class[]{
  			    NonblockingNumberConsumer.class
  		    });
  	private DataState dataState = new DataState(DataState.UNDEFINED);
  	private int suspendCount = 0;
  	private DataSource dataSource;
  	private Converter converter;
  	private InfoDialog infoDialog;
  	private PopupManager popupManager;
  
  	/**
  	 * Creates WheelswitchDisplayer displayer.
  	 *
  	 * @param newValue
  	 */
  	public DoubleNumberDisplayer(double newValue)
  	{
  		this(newValue, true, true, false);
  	}
  
  	/**
  	 * Creates WheelswitchDisplayer displayer.
  	 */
  	public DoubleNumberDisplayer()
  	{
  		this(0.0);
  	}
  
  	/**
  	 * Creates WheelswitchDisplayer displayer.
 	 *
 	 * @param value inital value
 	 * @param resizable initial resizable flag
 	 * @param enchanced initial antialiasing flag
 	 * @param unitsWithTitle shows units in title label
 	 */
 	public DoubleNumberDisplayer(double value, boolean resizable,
 	    boolean enchanced, boolean unitsWithTitle)
 	{
 		super(new Double(value), "%+3.2f", "Double Number Field", null, resizable,
 		    enchanced, true, unitsWithTitle);
 		initialize();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#setAttributes(java.util.Map)
 	 */
 	public void setCharacteristics(Map characteristics)
 	{
 		if (characteristics == null) {
 			throw new NullPointerException("characteristics");
 		}
 
 		DisplayerUtilities.setCharacteristics(characteristics, this);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#getConsumers()
 	 */
 	public DataConsumer[] getConsumers()
 	{
 		return support.getConsumers();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDataConsumer(java.lang.Class)
 	 */
 	public DataConsumer getDataConsumer(Class type)
 	{
 		if (type == DoubleConsumer.class) {
 			return this;
 		}
 
 		return DoubleConsumerMulticaster.createDataConsumer(type, this);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#getDataState()
 	 */
 	public DataState getDataState()
 	{
 		return dataState;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDefaultDataConsumer()
 	 */
 	public DataConsumer getDefaultDataConsumer()
 	{
 		return this;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setGraphMax(double)
 	 */
 	public void setMaximum(double value)
 	{
 		super.setMaximumValue(new Double(value));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getGraphMax()
 	 */
 	public double getMaximum()
 	{
 		return super.getMaximumValue().doubleValue();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setGraphMin(double)
 	 */
 	public void setMinimum(double value)
 	{
 		super.setMinimumValue(new Double(value));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getGraphMin()
 	 */
 	public double getMinimum()
 	{
 		return super.getMinimumValue().doubleValue();
 	}
 
 	/**
 	 * Overriden to implement additional features loading.
 	 *
 	 * @param state to be loaded.
 	 */
 	public void setState(State state)
 	{
 		super.setState(state);
 
 		setMaximum(state.getDouble("maximum", getMaximum()));
 		setMinimum(state.getDouble("minimum", getMinimum()));
 	}
 
 	/**
 	 * Overriden to implement additional features saving.
 	 *
 	 * @return state of the component.
 	 */
 	public State getState()
 	{
 		State state = super.getState();
 
 		state.putDouble("maximum", getMaximum());
 		state.putDouble("minimum", getMinimum());
 
 		return state;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#getSupportedAttributes()
 	 */
 	public String[] getSupportedCharacteristics()
 	{
 		return DisplayerUtilities.COMMON_NUMERIC_DISPLAYER_CHARACTERISTICS;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#getSupportedConsumersTypes()
 	 */
 	@SuppressWarnings("unchecked")
 	public Class[] getAcceptableConsumerTypes()
 	{
 		return support.getAcceptableConsumerTypes();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#isSuspended()
 	 */
 	public boolean isSuspended()
 	{
 		return suspendCount > 0;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setValue(double)
 	 */
 	public void setValue(double value)
 	{
 		super.setDoubleValue(value);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getValue()
 	 */
 	public double getValue()
 	{
 		return super.getDoubleValue();
 	}
 
 	/**
 	 * Accepts only consumers, which support
 	 * <code>NonblockingNumberConsumer</code> which is used for receiving
 	 * updates from user.
 	 *
 	 * @see com.cosylab.gui.displayers.DataSource#addConsumer(com.cosylab.gui.displayers.DataConsumer)
 	 */
 	public void addConsumer(DataConsumer consumer) throws PropertyVetoException
 	{
 		if (consumer == null) {
 			throw new NullPointerException("consumer");
 		}
 
 		NonblockingNumberConsumer c = (NonblockingNumberConsumer)consumer
 			.getDataConsumer(NonblockingNumberConsumer.class);
 
 		if (c == null) {
 			throw new PropertyVetoException("Consumer '" + consumer
 			    + "' must support NonblockingNumberConsumer.", null);
 		}
 
 		support.addConsumer(c);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#cleanup()
 	 */
 	public void cleanup()
 	{
 		internalCleanup();
 		updateDataState(new DataState(DataState.NOT_INITIALIZED));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.core.CosyComponent#destroy()
 	 */
 	public void destroy()
 	{
 		cleanup();
 		support.removeAllConsumers();
 		dataState = null;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#removeConsumer(com.cosylab.gui.displayers.DataConsumer)
 	 */
 	public void removeConsumer(DataConsumer consumer)
 	{
 		support.removeConsumer(consumer);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#resume()
 	 */
 	public void resume()
 	{
 		if (suspendCount > 0) {
 			suspendCount--;
 		}
 
 		if (suspendCount == 0) {
 			setEnabled(true);
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.CommonDisplayer#suspend()
 	 */
 	public void suspend()
 	{
 		setEnabled(false);
 		suspendCount++;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#updateDataState(com.cosylab.gui.displayers.DataState)
 	 */
 	public void updateDataState(DataState state)
 	{
 		DataState old = dataState;
 		dataState = state;
 		firePropertyChange(DATA_STATE, old, dataState);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleConsumer#updateValue(long, double)
 	 */
 	public void updateValue(long timestamp, double value)
 	{
 		setValue(value);
 	}
 
 	private void initialize()
 	{
 		setNumberType(double.class);
 
 		// adds set listener, which fires data source updates
 		addSetListener(new SetListener() {
 				public void setPerformed(SetEvent e)
 				{
 					try {
 						double value = e.getDoubleValue();
 
 						DataConsumer[] d = getConsumers();
 						
 						for (int i = 0; i < d.length; i++) {
 							NonblockingNumberConsumer dd = (NonblockingNumberConsumer)d[i];
 							
 							if (dd != null) {
 								dd.updateNonblocking(new Double(value));
 						
 							}
 						}
 					} catch (Exception ex) {
 						ex.printStackTrace();
 					}
 				}
 			});
 		setMaximum(100);
 		setMinimum(0);
 		setEditable(true);
 		setLayoutOrientation(AbstractDisplayerPanel.DYNAMIC_LAYOUT);
 		setBoundsVisible(false);
 		setTiltingEnabled(true);
 		setColumns(5);		
 		setWarnOutOfBounds(true);
 		setPopupEnabled(true);
 	}
 
 	private void internalCleanup()
 	{
 		setEnhanced(true);
 		setResizable(true);
 		setMaximum(100);
 		setMinimum(0);
 		setValue(0);
 		setTitle("Double Number Field");
 		setUnits(null);
 		setFormat(null);
 		setLayoutOrientation(AbstractDisplayerPanel.DYNAMIC_LAYOUT);
 		setBoundsVisible(false);
 		setUnitsVisible(true);
 		setTitleVisible(true);
 		setEditable(true);
 		setTiltingEnabled(true);
 		setColumns(5);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getSupportedConsumerTypes()
 	 */
 	@SuppressWarnings("unchecked")
 	public Class[] getSupportedConsumerTypes()
 	{
 		return DoubleConsumerMulticaster.PREFERED_CONSUMER_TYPES;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#getDataSource()
 	 */
 	public DataSource getDataSource()
 	{
 		return dataSource;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#setDataSource(com.cosylab.gui.displayers.DataSource)
 	 */
 	public void setDataSource(DataSource dataSource)
 		throws PropertyVetoException
 	{
 		DisplayerUtilities.prepareNewDataSource(dataSource,this);
 		
 		DataSource old= this.dataSource;
 		this.dataSource = dataSource;
 		
 		firePropertyChange(DATA_SOURCE,old,dataSource);
 	}
 
 	
 	/**
 	 * Returns the converter.
 	 * @return Returns the converter.
 	 */
 	public Converter getConverter() {
 		return converter;
 	}
 
 	
 	/**
 	 * Sets new converter.
 	 * @param converter The converter to set.
 	 * @throws PropertyVetoException if set fails
 	 */
 	public void setConverter(Converter converter) throws PropertyVetoException {
 		if (this.converter != null && this.converter.equals(converter) ||
 				(this.converter == null && converter == null)) return;
 		DisplayerUtilities.prepareNewConverter(converter,this);
 		
 		Converter old= this.converter;
 		this.converter = converter;
 		
 		firePropertyChange(CONVERTER_PROPERTY,old,this.converter);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#removeAllConsumers()
 	 */
 	public void removeAllConsumers()
 	{
 		support.removeAllConsumers();
 	}
 	
 	public InfoDialog getInfoDialog() {
 		if (infoDialog == null) {
 			infoDialog = new InfoDialog(this);
 		}
 		return infoDialog;
 	}
 	
 	public PopupManager getPopupManager()
 	{
 		if (popupManager == null) {
 			popupManager = super.getPopupManager();
 			popupManager.addAction(new AbstractAction("Info...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						getInfoDialog().setVisible(true);
 					}
 				});
 		}
 		
 		return popupManager;
 	}
 }
 
 /* __oOo__ */