/*
    * 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;
  
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.Font;
  
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.TransferHandler;
  
  import com.cosylab.application.state.State;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.range2.RangedValuePolicy;
  import com.cosylab.gui.components.util.CosyTransferHandler;
  import com.cosylab.gui.components.util.PopupManager;
  
  
  /**
   * <code>LabelledGauger</code> is an extension of AbstractDisplayerPanel which
   * provides <code>Gauger</code> as the numerical value displayer.  
   * 
   * @see AbstractDisplayerPanel
   * @see Gauger
   * @version 1.0
   */
  public class LabelledGauger extends AbstractDisplayerPanel
  {
  	private static final long serialVersionUID = 1L;
  	private Gauger gauger = null;
  	private AbstractCustomizerPanel customizer;
  	
  	/**
  	 * Creates new gauger displayer with the given title.
  	 */
  	public LabelledGauger(String title)
  	{
  		super();
  		setTitle(title);
  		setTitleVisible(true);
  		setLayoutOrientation(VERTICAL_LAYOUT);
  		setResizable(true);
  		setEnhanced(true);
  		setValue(5);
  		setFormat("%1.1f");
  		setUnits("");
  	}
  
  	/**
  	 * Creates new gauger displayer.
  	 */
  	public LabelledGauger()
  	{
  		this(null);
  	}
  
  	/* (non-Javadoc)
  	 * @see com.cosylab.gui.displayers.Displayer#isEditable()
  	 */
  	public boolean isEditable()
  	{
  		return false;
  	}
  
  	/* (non-Javadoc)
  	 * @see com.cosylab.gui.displayers.DoubleDisplayer#setFormat(java.lang.String)
  	 */
  	public void setFormat(String value)
  	{
  		String oldValue = getFormat();
  		getGauger().setFormat(value);
  		firePropertyChange("format", oldValue, value);
  	}
  
  	/* (non-Javadoc)
  	 * @see com.cosylab.gui.displayers.DoubleDisplayer#getFormat()
  	 */
  	public String getFormat()
  	{
  		return getGauger().getFormat();
  	}
 
 	/**
 	 * Switches between the logarithmic and linear scale.
 	 * 
 	 * @param b true if scale should be logarithmic
 	 */
 	public void setLogarithmicScale(boolean b)
 	{
 		if (b) {
 			setLogarithmicScale();
 		} else {
 			setLinearScale();
 		}
 	}
 
 	/**
 	 * Returns true if logarithmic scale is used.
 	 * 
 	 * @return
 	 */
 	public boolean isLogarithmicScale()
 	{
 		return getGauger().isLogarithmicScale();
 	}
 
 	/**
 	 * Sets the maximum value used by the displayer.
 	 * 
 	 * @param value new maximum
 	 */
 	public void setMaximum(double value)
 	{	
 		double oldValue = getMaximum();
 		getGauger().setMaximum(value);
 		firePropertyChange("maximum", oldValue, value);
 	}
 
 	/**
 	 * Returns the maximum value shown by displayer.
 	 * 
 	 * @return the maximum
 	 */
 	public double getMaximum()
 	{
 		return getGauger().getMaximum();
 	}
 
 	/**
 	 * Sets the minimum value shown by the displayer.
 	 * 
 	 * @param value new minimum
 	 */
 	public void setMinimum(double value)
 	{
 		double oldValue = getMinimum();
 		getGauger().setMinimum(value);
 		firePropertyChange("minimum", oldValue, value);
 	}
 
 	/**
 	 * Returns the minimum value shown by displayer.
 	 * 
 	 * @return the minimum
 	 */
 	public double getMinimum()
 	{
 		return getGauger().getMinimum();
 	}
 
 	/**
 	 * Sets the scale mode for the gauger.
 	 * 
 	 * @param policy
 	 * @deprecated use {@link #setValuePolicy(RangedValuePolicy)}
 	 * @see Gauger#setScaleMode(int)
 	 */
 	public void setScaleMode(int policy)
 	{
 		int oldValue = getScaleMode();
 		getGauger().setScaleMode(policy);
 		firePropertyChange("scaleMode", oldValue, policy);
 	}
 
 	/**
 	 * Returns the scale mode of the gauger.
 	 * 
 	 * @return the scale mode
 	 * @deprecated use {@link #getValuePolicy()}
 	 * @see Gauger#getScaleMode()
 	 */
 	public int getScaleMode()
 	{
 		return getGauger().getScaleMode();
 	}
 	
 	/**
 	 * Sets a new value policy.
 	 * 
 	 * @param policy new value policy
 	 */
 	public void setValuePolicy(RangedValuePolicy policy) {
 		RangedValuePolicy oldValue = getValuePolicy();
 		getGauger().setValuePolicy(policy);
 		firePropertyChange("valuePolicy", oldValue, policy);
 	}
 	
 	/**
 	 * Returns the value policy.
 	 * 
 	 * @return value policy
 	 */
 	public RangedValuePolicy getValuePolicy() {
 		return getGauger().getValuePolicy();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateOriginator#setState(com.cosylab.application.state.State)
 	 */
 	public void setState(State state)
 	{
 		super.setState(state);
 		getGauger().setState(state.getState("gauger"));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateOriginator#getState()
 	 */
 	public State getState()
 	{
 		State state = super.getState(); 
 		state.putState("gauger",getGauger().getState());
 		return state;
 	}
 
 	/**
 	 * Toggles the units visibility.
 	 * 
 	 * @param b true if units are visible
 	 */
 	public void setUnitsVisible(boolean b) {
 		boolean oldB = isUnitsVisible();
 		
 		if (oldB == b) return;
 		
 		getGauger().setUnitsVisible(b);
 		
 		firePropertyChange("unitsVisible",oldB,b);
 	}
 	
 	/**
 	 * Returns true if units are visible.
 	 * 
 	 * @return true if units are displayed.
 	 */
 	public boolean isUnitsVisible() {
 		return getGauger().isUnitsVisible();
 	}
 	
 	/**
 	 * Returns the Gauger displayer associated with this component.
 	 * 
 	 * @return
 	 */
 	protected Gauger getGauger() {
 		if (gauger==null) {
 			gauger = new Gauger(){
 				private static final long serialVersionUID = 1L;
 				
 				public AbstractCustomizerPanel getCustomizer()
 				{
 					if (customizer == null) {
 						customizer = AbstractCustomizerPanel.findCustomizer(LabelledGauger.this);
 					}
 
 					return customizer;
 				}
 			};
 			Dimension size = new Dimension(250, 150);
 			gauger.setPreferredSize(size);
 			gauger.setSize(size);
 			gauger.setMinimumSize(new Dimension(120,85));
 		}
 		return gauger;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.AbstractDisplayerPanel#getValueComponent()
 	 */
 	@Override
 	protected JComponent getValueComponent() {
 		return getGauger();
 	}
 		
 	/**
 	 * Returns the actual value on the displayer.
 	 * 
 	 * @return the value
 	 */
 	public double getValue() {
 		return getGauger().getValue();
 	}
 	
 	/**
 	 * Sets the value to the displayer.
 	 * 
 	 * @param d new value
 	 */
 	public void setValue(double d) {
 		double oldValue = getValue();
 		getGauger().setValue(d);
 		firePropertyChange("value", oldValue, d);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.AbstractDisplayerPanel#layoutDisplayer()
 	 */
 	@Override
 	protected void layoutDisplayer() {
 		super.layoutDisplayer();
 		getGauger().doLayout();
 	}
 	
 	/**
 	 * Returns the string representing the units.
 	 * 
 	 * @return the units
 	 */
 	public String getUnits() {
 		return getGauger().getUnits();
 	}
 	
 	/**
 	 * Sets the units shown by this displayer.
 	 * 
 	 * @param u new units
 	 */
 	public void setUnits(String u) {
 		String oldValue = getUnits();
 		getGauger().setUnits(u);
 		firePropertyChange("units", oldValue, u);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.AbstractDisplayerPanel#getCustomizer()
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 
 		return customizer;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.AbstractDisplayerPanel#getPopupManager()
 	 */
 	public PopupManager getPopupManager()
 	{
 		return getGauger().getPopupManager();
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.AbstractDisplayerPanel#setPopupEnabled(boolean)
 	 */
 	@Override
 	public void setPopupEnabled(boolean enabled) {
 		getGauger().setPopupEnabled(enabled);
 		super.setPopupEnabled(enabled);
 	}
 
 	/**
 	 * Returns the font used to display value.
 	 * 
 	 * @return the value font
 	 */
 	public Font getValueLabelFont() {
 	    return gauger.getValueLabelFont();
     }
 	
 	/**
 	 * Sets the font used to display value.
 	 * 
 	 * @param font new font
 	 */
 	public void setValueLabelFont(Font font) {
 		Font oldValue = getValueLabelFont();
 		gauger.setValueLabelFont(font);
 		firePropertyChange("valueLabelFont", oldValue, font);
 	}
 	
 	/**
 	 * Convenient method to set logarithmic scale.
 	 *
 	 */
 	public void setLogarithmicScale() {
 		boolean oldValue = isLogarithmicScale();
 		gauger.setLogarithmicScale();
 		firePropertyChange("logarithmicScale", oldValue, true);
 	}
 	
 	/**
 	 * Convenient method to set linear scale.
 	 *
 	 */
 	public void setLinearScale() {
 		boolean oldValue = isLinearScale();
 		gauger.setLinearScale();
 		firePropertyChange("linearScale", oldValue, true);
 	}
 	
 	/**
 	 * Convenient method to see if linear scale is used.
 	 * 
 	 * @return
 	 */
 	public boolean isLinearScale() {
 		return gauger.isLinearScale();
 	}
 	
 	/**
 	 * Sets the color which indicates that the value is out of bounds.
 	 * 
 	 * @param color new out of bounds color
 	 */
 	public void setOutOfBoundsColor(Color color) {
 		Color oldValue = gauger.getOutOfBoundsColor();
 		gauger.setOutOfBoundsColor(color);
 		firePropertyChange("outOfBoundsColor", oldValue, color);
 	}
 	
 	/**
 	 * Returns the value which indicates that the value is out of bounds.
 	 * 
 	 * @return the out of bounds color
 	 */
 	public Color getOutOfBoundsColor() {
 		return gauger.getOutOfBoundsColor();
 	}
 	
 	/**
 	 * Returns the color which indicates the warning.
 	 * 
 	 * @return the warning color
 	 */
 	public Color getWarningColor() {
 		return gauger.getWarningColor();
 	}
 	
 	/**
 	 * Sets the warning color for the gauger.
 	 * 
 	 * @param color new warning color
 	 */
 	public void setWarningColor(Color color) {
 		Color oldValue = gauger.getWarningColor();
 		gauger.setWarningColor(color);
 		firePropertyChange("warningColor", oldValue, color);
 	}
 	
 	/**
 	 * Sets new upper warning limit. At this value the needle will 
 	 * change its color to the set warning color. The limit should be given 
 	 * in percentage of the current span of the gauger.
 	 *  
 	 * @param value new warning limit
 	 */
 	public void setHighWarningLimit(double value) {
 		double oldValue = gauger.getHighWarningLimit();
 		gauger.setHighWarningLimit(value);
 		firePropertyChange("highWarningLimit", oldValue, value);
 	}
 	
 	/**
 	 * Returns the upper warning limit.
 	 * 
 	 * @return upper warning limit
 	 */
 	public double getHighWarningLimit() {
 		return gauger.getHighWarningLimit();
 	}
 	
 	/**
 	 * Sets new lower warning limit. At this value the needle will 
 	 * change its color to the set warning color. The limit should be given 
 	 * in percentage of the current span of the gauger.
 	 *  
 	 * @param value new warning limit
 	 */
 	public void setLowWarningLimit(double value) {
 		double oldValue = gauger.getLowWarningLimit();
 		gauger.setLowWarningLimit(value);
 		firePropertyChange("lowWarningLimit", oldValue, value);
 	}
 	
 	/**
 	 * Returns the lower warning limit.
 	 * 
 	 * @return upper warning limit
 	 */
 	public double getLowWarningLimit() {
 		return gauger.getLowWarningLimit();
 	}
 	
 	/**
 	 * Sets new value and bounds to the displayer.
 	 * 
 	 * @param newMin new minimum
 	 * @param newMax new maximum
 	 * @param newValue new maximum
 	 */
 	public void setValue(double newMin, double newMax, double newValue) {
 		double oldValue = getValue();
 		gauger.setValue(newMin, newMax, newValue);
 		firePropertyChange("value", oldValue, newValue);
 	}
 	
     /* (non-Javadoc)
      * @see javax.swing.JComponent#setTransferHandler(javax.swing.TransferHandler)
      */
     @Override
     public void setTransferHandler(TransferHandler newHandler) {
     	super.setTransferHandler(newHandler);
     	CosyTransferHandler.registerTransferHandler(this,newHandler,new JComponent[]{getValueComponent()});
     }
     
     /**
 	 * Run test applet.
 	 *
 	 * @param args command line parameters
 	 */
 	public static void main(String[] args)
 	{
 		Thread t = new Thread(){
 			public void run(){
 				JFrame f= new JFrame();
 				f.setSize(400,400);
 				f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 				
 				LabelledGauger g= new LabelledGauger("Labelled Gauger");
 //				g.setMaximum(100);
 //				g.setMinimum(0);
 //				g.setValue(50);
 				g.setResizable(true);
 				g.setUnits("V");
 				g.setFormat("%1.2f");
 				f.getContentPane().add(g);
 				
 				f.setVisible(true);
 //				while (true){
 //					g.setValue(g.getMinimum() + Math.random() * (g.getMaximum() - g.getMinimum()));
 //					
 //					try {
 //						sleep(500);
 //					} catch (InterruptedException e) {
 //						break;
 //					}
 //				}
 			}
 		};
 		t.run();
 	}
 
 }
 
 /* __oOo__ */