package com.cosylab.gui;
   
   import java.awt.Component;
   import java.awt.event.ActionEvent;
   import java.awt.event.ActionListener;
   import java.awt.event.MouseAdapter;
   import java.awt.event.MouseEvent;
   import java.beans.Beans;
   import java.beans.PropertyVetoException;
  import java.util.Map;
  
  import javax.swing.AbstractAction;
  import javax.swing.JCheckBox;
  import javax.swing.JDialog;
  
  import com.cosylab.gui.adapters.Converter;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.util.PopupManager;
  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;
  import com.cosylab.util.CommonException;
  
  /**
   * CheckBox for displaying and switching double properties between two values.
   * To set the values, see methods {@link #setSelectedValue(Number)} and
   * {@link #setDeselectedValue(Number)}.
   * 
   * @author <a href="mailto:blaz.hostnik@cosylab.com">Blaz Hostnik, Cosylab</a>
   */
  public class CheckBoxController extends JCheckBox implements DoubleDisplayer, DataSource, ConvertibleDisplayer {
  	
  	private static final long serialVersionUID = -84774768633096095L;
  	/** This value is going to be set to consumers when CheckBox is selected. */
  	public static final String SELECTED_VALUE = "selectedValue";
  	/** This value is going to be set to consumers when CheckBox is deselected. */
  	public static final String DESELECTED_VALUE = "deselectedValue";
  	
  	protected static final String DEFAULT_TEXT = "Enable";
  	
  	private String title;
  	private DataSource dataSource;
  	private DataState dataState = new DataState(DataState.UNDEFINED);
  	private int suspendCount = 0;
  	private PopupManager popupManager;
  	private InfoDialog infoDialog;
  	private AbstractCustomizerPanel customizer;	
  	@SuppressWarnings("unchecked")
  	private DataSourceSupport support = new DataSourceSupport(new Class[]{
  		    NonblockingNumberConsumer.class
  	    });
  	private Converter converter;
  
  	private Number selectedValue = 1;
  
  	private Number deselectedValue = 0;	
  
  	private boolean popupEnabled = false;
  
  	private double minimum;
  
  	private double maximum;
  
  	private String units;
  
  	private double value;
  
  	private String format;
  	
  	/*
  	 * Used for responding to selections and deselections.
  	 */
  	private class CheckBoxListener implements ActionListener {
  		
  		public void actionPerformed(ActionEvent e) {
  			DataConsumer[] d = getConsumers();
  			boolean sel = isSelected();
  
  			for (int i = 0; i < d.length; i++) {
  				NonblockingNumberConsumer dd = (NonblockingNumberConsumer)d[i];
  
  				if (dd != null) {
  					if (sel) dd.updateNonblocking(selectedValue);
  					else dd.updateNonblocking(deselectedValue);
  				}
  			}
  
  		}
  		
  	}
  
  	
 	/**
 	 * Default constructor: with {@link #DEFAULT_TEXT} text in front of the check box.
 	 */
 	public CheckBoxController() {
 		this(DEFAULT_TEXT);
 	}
 	
 	/**
 	 * Constructor with parameters.
 	 * 
 	 * @param text in front of the check box
 	 */
 	public CheckBoxController(String text) {
 		setText(text);
 		initialize();
 	}
 	
 	protected void initialize(){
 		this.addActionListener(new CheckBoxListener());
 		
 		addMouseMotionListener(new MouseAdapter() {			
 			public void mouseDragged(MouseEvent e) {
 				//this is necessary for check box to be released
 				processMouseEvent(new MouseEvent((Component)e.getSource(), MouseEvent.MOUSE_EXITED, e.getWhen(),
 						e.getModifiers(), e.getX(), e.getY(), e.getClickCount(), false));
 			}
 		});
 		
 		setPopupEnabled(true);
 	}
 	
 	/**
 	 * Set the value that will be set on consumers, when the CheckBox will be selected.
 	 */
 	public void setSelectedValue(Number value){
 		if (selectedValue == value) return;
 		
 		Number old = selectedValue;
 		selectedValue = value;
 		
 		firePropertyChange(SELECTED_VALUE,old,selectedValue);		
 	}
 
 	/**
 	 * Get the value that will be set on consumers, when the CheckBox will be selected.
 	 */
 	public Number getSelectedValue(){
 		return selectedValue;
 	}
 	
 	/**
 	 * Set the value that will be set on consumers, when the CheckBox will be deselected.
 	 */
 	public void setDeselectedValue(Number value){
 		if (deselectedValue == value) return;
 		
 		Number old = deselectedValue;
 		deselectedValue = value;
 		
 		firePropertyChange(DESELECTED_VALUE,old,deselectedValue);		
 	}
 
 	/**
 	 * Get the value that will be set on consumers, when the CheckBox will be deselected.
 	 */
 	public Number getDeselectedValue(){
 		return deselectedValue;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getFormat()
 	 */
 	public String getFormat() {
 		return format;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getMaximum()
 	 */
 	public double getMaximum() {
 		return maximum;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getMinimum()
 	 */
 	public double getMinimum() {
 		return minimum;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getUnits()
 	 */
 	public String getUnits() {
 		return units;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getValue()
 	 */
 	public double getValue() {
 		return value;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setFormat(java.lang.String)
 	 */
 	public void setFormat(String value) {
 		if (format == null) {
 			if (value == null) return;
 		} else if (format.equals(value)) return;		
 
 		String oldValue = format;
 		format = value;
 
 		firePropertyChange("format", oldValue, format);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setMaximum(double)
 	 */
 	public void setMaximum(double value) {
 		if (value == maximum) return;
 
 		double oldValue = maximum;
 		maximum = value;
 
 		firePropertyChange("maximum", oldValue, maximum);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setMinimum(double)
 	 */
 	public void setMinimum(double value) {
 		if (value == minimum) return;
 
 		double oldValue = minimum;
 		minimum = value;
 
 		firePropertyChange("minimum", oldValue, minimum);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setUnits(java.lang.String)
 	 */
 	public void setUnits(String value) {
 		if (units == null) {
 			if (value == null) return;
 		} else if (units.equals(value)) return;		
 
 		String oldValue = units;
 		units = value;
 
 		firePropertyChange("units", oldValue, units);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setValue(double)
 	 */
 	public void setValue(double val) {
 		if (val == value) return;
 
 		double oldValue = value;
 		value = val;
 
 		firePropertyChange("value", oldValue, value);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#getDataSource()
 	 */
 	public DataSource getDataSource() {
 		return dataSource;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#getTitle()
 	 */
 	public String getTitle() {
 		return title;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#isEditable()
 	 */
 	public boolean isEditable() {
 		return true;
 	}
 
 	/*
 	 * (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);
 	}
 
 	protected void internalSetTitle()
 	{
 		String value = title;
 
 		if (value == null && Beans.isDesignTime()) {
 			value = "<title>";
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.Displayer#setTitle(java.lang.String)
 	 */
 	public void setTitle(String value) {
 		String oldVal = title;
 		title = value;
 		internalSetTitle();
 		firePropertyChange("title", oldVal, value);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDataConsumer(java.lang.Class)
 	 */
 	@SuppressWarnings("unchecked")
 	public DataConsumer getDataConsumer(Class type) {
 		if (type == DoubleConsumer.class) {
 			return this;
 		}
 
 		return DoubleConsumerMulticaster.createDataConsumer(type, this);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getDefaultDataConsumer()
 	 */
 	public DataConsumer getDefaultDataConsumer() {
 		return this;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getSupportedCharacteristics()
 	 */
 	public String[] getSupportedCharacteristics() {
 		return DisplayerUtilities.COMMON_NUMERIC_DISPLAYER_CHARACTERISTICS;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#getSupportedConsumerTypes()
 	 */
 	@SuppressWarnings("unchecked")
 	public Class<DataConsumer>[] getSupportedConsumerTypes() {
 		return DoubleConsumerMulticaster.PREFERED_CONSUMER_TYPES;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataConsumer#setCharacteristics(java.util.Map)
 	 */
 	@SuppressWarnings("unchecked")
 	public void setCharacteristics(Map characteristics) {
 		if (characteristics == null) {
 			throw new NullPointerException("characteristics");
 		}
 
 		DisplayerUtilities.setCharacteristics(characteristics, this);
 	}
 
 	/*
 	 * (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);
 	}
 
 	private void internalCleanup() {
 		setText(DEFAULT_TEXT);
 		setTitle(null);
 		setSelected(false);
 	}
 
 	/*
 	 * (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.displayers.CommonDisplayer#isSuspended()
 	 */
 	public boolean isSuspended() {
 		return suspendCount > 0;
 	}
 
 	/*
 	 * (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.components.util.PopupManageable#getPopupManager()
 	 */
 	public PopupManager getPopupManager() {
 		if (popupManager == null) {
 			popupManager = new PopupManager(this, false);
 			popupManager.addAction(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 					public void actionPerformed(ActionEvent e)
 					{
 						getCustomizer().showDialog();
 					}
 				});
 			
 			popupManager.addAction(new AbstractAction("Info...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						getInfoDialog().setVisible(true);
 					}
 				});
 		}
 		
 		return popupManager;
 	}
 	
 	/**
 	 * Return true if the popup menu is enabled or false otherwise.
 	 * 
 	 * @return true if popup is enabled
 	 */
 	public boolean isPopupEnabled() {
 		return popupEnabled;
 	}
 	
 	/**
 	 * Enables or disables the popup menu.
 	 * 
 	 * @param enabled true if enable or false if disableds
 	 */
 	public void setPopupEnabled(boolean enabled) {
 		if (popupEnabled == enabled) return;
 		popupEnabled = enabled;
 		if (enabled) {
 			addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			removeMouseListener(getPopupManager().getMouseHook());
 		}		
 		firePropertyChange("popupEnabled",!popupEnabled,popupEnabled);
 	}	
 
 	protected JDialog getInfoDialog() {
 		if (infoDialog == null) {
 			infoDialog = new InfoDialog(this);
 		}
 		return infoDialog;
 	}
 
 	protected AbstractCustomizerPanel getCustomizer() {
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 		return customizer;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataStateProvider#getDataState()
 	 */
 	public DataState getDataState() {
 		return dataState;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DoubleConsumer#updateValue(long, double)
 	 */
 	public void updateValue(long timestamp, double value)
 			throws CommonException {
 		if (value == selectedValue.doubleValue()) {
 			setSelected(true);
 			updateDataState(new DataState(DataState.NORMAL));
 		}
 		else if (value == deselectedValue.doubleValue()){
 			setSelected(false);
 			updateDataState(new DataState(DataState.NORMAL));
 		}
 		else {
 			updateDataState(new DataState(DataState.WARNING));
 		}
 	}
 
 	/**
 	 * 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.DataSource#getAcceptableConsumerTypes()
 	 */
 	public Class<DataConsumer>[] getAcceptableConsumerTypes() {
 		return support.getAcceptableConsumerTypes();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#getConsumers()
 	 */
 	public DataConsumer[] getConsumers() {
 		return support.getConsumers();
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.DataSource#removeAllConsumers()
 	 */
 	public void removeAllConsumers() {
 		support.removeAllConsumers();
 	}
 
 	/*
 	 * (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.ConvertibleDisplayer#getConverter()
 	 */
 	public Converter getConverter() {
 		return converter;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.displayers.ConvertibleDisplayer#setConverter(com.cosylab.gui.adapters.Converter)
 	 */
 	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);
 	}
 
 }