/*
    * 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.Font;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.event.ActionEvent;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.awt.image.BufferedImage;
  
  import javax.swing.AbstractAction;
  import javax.swing.JPanel;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.gauger.Needle;
  import com.cosylab.gui.components.gauger.ScaleTransform;
  import com.cosylab.gui.components.gauger.ScaleTransformFactory;
  import com.cosylab.gui.components.gauger.ScaleTransformRenderer;
  import com.cosylab.gui.components.gauger.ValueLabel;
  import com.cosylab.gui.components.range2.LinearRange;
  import com.cosylab.gui.components.range2.LogarithmicRange;
  import com.cosylab.gui.components.range2.ManualTickCalculator;
  import com.cosylab.gui.components.range2.RangedValueController;
  import com.cosylab.gui.components.range2.RangedValueEvent;
  import com.cosylab.gui.components.range2.RangedValueListener;
  import com.cosylab.gui.components.range2.RangedValuePolicy;
  import com.cosylab.gui.components.range2.RescalingValuePolicy;
  import com.cosylab.gui.components.range2.ShiftValuePolicy;
  import com.cosylab.gui.components.range2.Tick;
  import com.cosylab.gui.components.range2.TickParameters;
  import com.cosylab.gui.components.range2.TrimValuePolicy;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.PaintHelper;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.ScreenCapturer;
  import com.cosylab.util.PrintfFormat;
  
  
  /**
   * Gauger is a visual component that displays a value on a scale between
   * minimum and maximum. Shape and visual layout of the component will change
   * to best fit into the available space. Behaviour of the scale can be
   * adjusted to fixed (lower and upper bound cannot change), constant span
   * (scale will always span fixed ammount) or rescaling (lower and upper bound
   * will adjust to accomodate current value). Supported scales are linear and
   * logarithmic.
   * 
   * <p>
   * For accurate readouts, the currently set value is also displayed in custom
   * formatted label.
   * </p>
   * 
   * <p>
   * Gauger is aimed to provide fastest possible response to value changes.
   * </p>
   *
   * @author Ales Pucelj
   * @version $id$
   */
  public class Gauger extends JPanel implements TickParameters, PopupManageable, /* implements TickCallback - edit apikus */
  	StateOriginator
  {
  	private static final long serialVersionUID = 1L;
  	
  	/**
  	 * Fixed limits scale.
  	 *
  	 * @see #setScaleMode(int)
  	 * @deprecated replaced by {@link TrimValuePolicy}
  	 */
  	public static final int FIXED_SCALE = 0;
 
 	/**
 	 * Constant span scale.
 	 *
 	 * @see #setScaleMode(int)
 	 * @deprecated replaced by {@link ShiftValuePolicy}
 	 */
 	public static final int CONSTANT_SPAN = 1;
 
 	/**
 	 * Resizable scale.
 	 *
 	 * @see #setScaleMode(int)
 	 * @deprecated replaced by {@link RescalingValuePolicy}
 	 */
 	public static final int STRETCH_SCALE = 2;
 	
 	private AbstractCustomizerPanel customizer;
 	
 	private PopupManager popupManager;
 	
 	/**
 	 * Gauger preferences
 	 */
 	private Color scaleColor = new Color(239, 239, 239);
 	private Color needleColor = new Color(0, 192, 0);
 	private Color alarmColor = new Color(239,0,0);
 	private Color warningColor = new Color(0xEEEC300);
 	private Color outOfBoundsColor = new Color(239,0,0);
 
 	private Font tickTextFont = new Font("Serif", Font.PLAIN, 12);
 	private Font valueLabelFont = new Font("dialog", Font.PLAIN, 12);
 	
 	/* the size of range values for scale limit */
 
 	private double lowAlarmLimit = 0.05;
 	private double lowWarningLimit= 0.2;
 	private double highWarningLimit= 0.8;
 	private double highAlarmLimit= 0.95;
 	private PrintfFormat formatter = new PrintfFormat("%3.2f");	
 	protected RangedValueController userRangedValue; /* edit apikus */
 	private BufferedImage buffer = null;
 	private ScaleTransformRenderer scaleRenderer = null;
 	private ScaleTransform transform = null;
 	protected Needle needle = null;
 	private ValueLabel valueLabel = null;
 	private double labelValue;
 	private Tick[] ticks = null;
 	private String title = "";
 	private boolean titleVisible = false;
 	private int titleMinimumFontSize = 2;
 	private int titleMaximumFontSize = 20;
 	private boolean resizable = true;
 	private boolean popupEnabled;
 	
 	private class ComponentListener extends ComponentAdapter
 	{
 		/**
 		 * Clears background and tick buffer whenever the component is resized.
 		 * Buffer will be regenerated on next call to repaint.
 		 *
 		 * @param e ComponentEvent
 		 *
 		 * @see java.awt.event.ComponentListener#componentResized(ComponentEvent)
 		 */
 		public void componentResized(ComponentEvent e)
 		{
 			if (e.getSource() == Gauger.this) {
 				synchronized (Gauger.this) {
 					transform = null;
 					clearBuffer();
 					repaint();
 				}
 			}
 		}
 
 		/**
 		 * Disposes the buffer whenever the component is hidded to minimize
 		 * memory use whenever the component is not visible.
 		 *
 		 * @param e ComponentEvent
 		 *
 		 * @see ComponentListener#componentHidden(ComponentEvent)
 		 */
 		public void componentHidden(ComponentEvent e)
 		{
 			super.componentHidden(e);
 			clearBuffer();
 		}
 	}
 
 	private class ValueListener implements RangedValueListener
 	{
 		/**
 		 * Responds to value changes by either repainint the background or only
 		 * updating the needle position.
 		 *
 		 * @see com.cosylab.gui.components.range.RangedValueListener#valueChanged(RangedValueEvent)
 		 */
 		public void valueChanged(RangedValueEvent event)
 		{
 			
 			synchronized (Gauger.this) {
 				if (event.isMinimumChanged() || event.isMaximumChanged()) {
 					clearBuffer();
 					repaint();
 				}
 
 			
 				Needle needle = getNeedle();
 				Rectangle oldArea = needle.getBounds();
 
 
 				
 				if(getValue()>getMaximum()) {
 					needle.setPosition(userRangedValue.getRelativeValue()+0.05); /* edit apikus */
 				} else if (getValue()<getMinimum()){
 					needle.setPosition(userRangedValue.getRelativeValue()-0.05);
 				} else {
 					needle.setPosition(userRangedValue.getRelativeValue());
 				}
 			
 				if (needle.isChangeSignificant()) {
 					repaint(oldArea);
 					repaint(needle.getBounds());
 				}
 
 				ValueLabel vl = getValueLabel();
 				oldArea = vl.getBounds();
 
 				if (vl.isChangeSignificant()) {
 					repaint(oldArea);
 					repaint(vl.getBounds());
 				}
 			}
 		}
 	}
 
 	/**
 	 * Creates a new gauger and sets the default parameters.
 	 */
 	public Gauger()
 	{
 		super();
 
 		userRangedValue = new RangedValueController(); /* edit apikus */
 		userRangedValue.setRange(new LinearRange());
 		userRangedValue.addPolicy(new RescalingValuePolicy());
 		userRangedValue.addRangedValueListener(new ValueListener());
 		
 		//default is fixed_scale
 		setScaleMode(Gauger.FIXED_SCALE);
 		setBackground(ColorHelper.getCosyControl());
 		scaleRenderer = new ScaleTransformRenderer(this);
 
 		setDoubleBuffered(false);
 		setOpaque(true);
 		setDropTarget(null);
 
 		addComponentListener(new ComponentListener());
 		setPopupEnabled(true);
 	}
 
 	/**
 	 * Creates a new buffer on which the scale background is rendered.  Buffer
 	 * should always be accessed via this method, since the buffer can  be
 	 * disposed if the component is not visible.
 	 *
 	 * @return BufferedImage
 	 */
 	private synchronized BufferedImage getBuffer()
 	{
 		if (buffer == null) {
 			int w = Math.max(getWidth(), 1);
 			int h = Math.max(getHeight(), 1);
 
 			buffer = new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
 
 			Graphics2D g2 = buffer.createGraphics();
 			g2.setRenderingHints(PaintHelper.getAntialiasingHints());
 
 			g2.setColor(getBackground());
 			g2.fillRect(0, 0, w, h);
 			scaleRenderer.render(getTransform(), g2);
 		}
 
 		return buffer;
 	}
 
 	/**
 	 * Sets behaviour of the scale. This can take one of 3 possible modes.<br>
 	 * 
 	 * <ul>
 	 * <li>
 	 * Gauger.FIXED_SCALE
 	 * </li>
 	 * <li>
 	 * Gauger.CONSTANT_SPAN
 	 * </li>
 	 * <li>
 	 * Gauger.STRETCH_SCALE
 	 * </li>
 	 * </ul>
 	 * 
 	 * <p>
 	 * FIXED_SCALE will fix the limits to any value regardless of the actual
 	 * value displayed by needle. If value displayed is outside limits, it
 	 * will be limited to either bound.
 	 * </p>
 	 * 
 	 * <p>
 	 * CONSTANT_SPAN will automatically move the scale based on needle
 	 * movement. If needle moves outside current limits, they will move in the
 	 * same  direction, but span (maximum-minimum) of the scale will remain
 	 * unchanged.
 	 * </p>
 	 * 
 	 * <p>
 	 * STRETCH_SCALE will change only one limit at the time whenever needle
 	 * moves outside current limits. Scale will not shrink back when needle is
 	 * within old bounds.
 	 * </p>
 	 *
 	 * @param mode New mode to set.
 	 * @deprecated use {@link #setValuePolicy(RangedValuePolicy)}
 	 */
 	public void setScaleMode(int mode)
 	{
 		int oldValue = getScaleMode();
 		switch (mode) {
 		case FIXED_SCALE:
 			setValuePolicy(new TrimValuePolicy());
 			break;
 
 		case CONSTANT_SPAN:
 			setValuePolicy(new ShiftValuePolicy());
 
 			break;
 
 		case STRETCH_SCALE:default:
 			setValuePolicy(new RescalingValuePolicy());
 
 			break;
 		}
 		
 		firePropertyChange("scaleMode", oldValue, mode);
 	}
 	
 	/**
 	 * Sets the RangedValuePolicy.
 	 * 
 	 * @param policy
 	 * @see #setScaleMode(int)
 	 */
 	public void setValuePolicy(RangedValuePolicy policy) {
 		RangedValuePolicy oldValue = getValuePolicy();
 		getRangedValue().setPolicy(policy);
 		firePropertyChange("valuePolicy", oldValue, policy);
 	}
 	
 	/**
 	 * Returns the RangedValuePolicy.
 	 * 
 	 * @return
 	 * @see #getScaleMode()
 	 */
 	public RangedValuePolicy getValuePolicy() {
 		return getRangedValue().getPolicy();
 	}
 
 	/**
 	 * Returns current scale mode. Return value will be one of <code>
 	 * Gauger.FIXED_SCALE</code>, <code>Gauger.CONSTANT_SPAN</code> or <code>
 	 * Gauger.STRETCH_SCALE</code>.
 	 *
 	 * @return One of scale mode constants.
 	 *
 	 * @see #setScaleMode(int)
 	 * @deprecated use {@link #getValuePolicy()}
 	 */
 	public int getScaleMode()
 	{
 		RangedValuePolicy p = getValuePolicy();
 
 		if (p instanceof TrimValuePolicy) {
 			return FIXED_SCALE;
 		}
 
 		if (p instanceof ShiftValuePolicy) {
 			return CONSTANT_SPAN;
 		}
 
 		return STRETCH_SCALE;
 	}
 
 	/**
 	 * Clears the background buffer and precalculated ticks.
 	 */
 	private synchronized void clearBuffer()
 	{
 		ticks = null;
 		buffer = null;
 		transform = null;
 	}
 
 	/**
 	 * Returns the current maximum value of the scale.
 	 *
 	 * @return double
 	 */
 	public double getMaximum()
 	{
 		return userRangedValue.getMaximum(); 
 	}
 
 	/**
 	 * Returns the current minimum value of the scale.
 	 *
 	 * @return double
 	 */
 	public double getMinimum()
 	{
 		return userRangedValue.getMinimum(); 
 	}
 
 	/**
 	 * Returns needle renderer. If needle does not exist, it will be created.
 	 * This method uses lazy initialization, so setting the needle field to
 	 * null will cause it to be recreated on next call.
 	 *
 	 * @return Needle needle renderer implementation.
 	 */
 	protected synchronized Needle getNeedle()
 	{
 		if (needle == null) {
 			needle = new Needle(this);
 			needle.setPosition(0.5);
 		}
 
 		return needle;
 	}
 
 	/**
 	 * Returns <code>RangedValueController</code>. This method can be used
 	 * to gain access to more advanced aspects of <code>RangedValueController</code>
 	 * Instance returned is not replacable.
 	 *
 	 * @return Instance of <code>RangedValue</code>
 	 */
 	public RangedValueController getRangedValue()
 	{
 		return userRangedValue;
 	}
 
 	/**
 	 * Returns the current value of the scale. This is the value displayed by
 	 * the needle. Regardles of the scale, this value is never log based.
 	 *
 	 * @return double
 	 */
 	public double getValue()
 	{
 		return labelValue;
 	}
 
 	/**
 	 * Gets the instance of the value label used to display current value.
 	 *
 	 * @return ValueLabel
 	 */
 	protected ValueLabel getValueLabel()
 	{
 		if (valueLabel == null) {
 			valueLabel = new ValueLabel(this);
 		}
 
 		return valueLabel;
 	}
 
 	/**
 	 * Sets format string of value label.
 	 *
 	 * @param format C-Style format of value label.
 	 */
 	public void setFormat(String format)
 	{
 		String old = getValueLabel().getFormat();
 
 		try {
 			getValueLabel().setFormat(format);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		formatter = new PrintfFormat(format);
 		repaint();
 
 		firePropertyChange("format", old, format);
 	}
 
 	/**
 	 * Returns format of value label.
 	 *
 	 * @return C-Style format of value label.
 	 */
 	public String getFormat()
 	{
 		return getValueLabel().getFormat();
 	}
 
 	/**
 	 * Sets units of value label.
 	 *
 	 * @param units String to be appended to value label. Can be null.
 	 */
 	public void setUnits(String units)
 	{
 		String oldValue = getUnits();
 		getValueLabel().setUnits(units);
 		repaint();
 		firePropertyChange("units", oldValue, units);
 	}
 
 	/**
 	 * Returns units string of value label.
 	 *
 	 * @return String representing the units. Can be null.
 	 */
 	public String getUnits()
 	{
 		return getValueLabel().getUnits();
 	}
 
 	/**
 	 * Sets units visible of value label.
 	 *
 	 * @param b whether units should be displayed.
 	 */
 	public void setUnitsVisible(boolean b)
 	{
 		if (this.isUnitsVisible() == b) return;
 		getValueLabel().setUnitsVisible(b);
 		repaint();
 		firePropertyChange("unitsVisible", !b, b);
 	}
 
 	/**
 	 * Returns unitsVisible of value label.
 	 *
 	 * @return true if units are visible
 	 */
 	public boolean isUnitsVisible()
 	{
 		return getValueLabel().isUnitsVisible();
 	}
 
 
 	/**
 	 * Sets the new value to be displayed on this scale. In this implementation
 	 * the value is shown by the needle and value label. The value is adjusted
 	 * according to the set value policy.
 	 *
 	 * @param newValue double
 	 */
 	public void setValue(double newValue)
 	{
 		double old = labelValue;
 		labelValue = newValue;
 		getValueLabel().setValue(labelValue);
 
 		try {
 			userRangedValue.setValue(newValue);
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 		
 		repaint();
 
 		firePropertyChange("value", new Double(old), new Double(newValue));
 	}
 
 	/**
 	 * Returns the information about the scale ticks. This method is used
 	 * internaly by renderers
 	 *
 	 * @return Tick[]
 	 */
 	public Tick[] getTicks()
 	{
 		if (ticks == null) {
 			//ticks = rangedValue.getRange().getTicks((int)getTransform().scaleWidth(0.7)).toTicks(this);
 			ticks = userRangedValue.calculateTicks((int)getTransform().scaleWidth(0.7), this); /* edit apikus */
 		}
 		return ticks;
 	}
 
 	/**
 	 * Returns current transform used to render the scale. This transform is
 	 * selected based on width and height of the component and is used when
 	 * rendering Gauger.
 	 *
 	 * @return ScaleTransform
 	 */
 	public ScaleTransform getTransform()
 	{
 		if (transform == null) {
 			transform = ScaleTransformFactory.createTransform(getWidth(),
 				    getHeight());
 
 			transform.setParameters(getWidth(), getHeight(), 0,
 			    getValueLabel().getBounds().height, Tick.TICKS_OFFSET_PIXELS);
 
 			getNeedle().setTransform(transform);
 			setValueLabelPosition(getTransform().getLabelPosition());
 		}
 
 		return transform;
 	}
 
 	/**
 	 * Sets the lower limit for the display. This value cannot be set above
 	 * current maximum, it can be however set above current value.
 	 *
 	 * @param newMin
 	 */
 	public void setMinimum(double newMin)
 	{
 		double oldValue = getMinimum();
 		userRangedValue.setValue(newMin, getMaximum(), getValue());
 		repaint();
 		firePropertyChange("minimum", oldValue, newMin);
 	}
 
 	/**
 	 * Sets the upper limit for the display. This value cannot be set below
 	 * current minimum, it can be however set below current value.
 	 *
 	 * @param newMax
 	 */
 	public void setMaximum(double newMax)
 	{
 		double oldValue = getMaximum();
 		userRangedValue.setValue(getMinimum(), newMax, getValue());
 		repaint();
 		firePropertyChange("maximum", oldValue, newMax);
 	}
 
 	/**
 	 * Sets the value and limits for the displayer.
 	 *
 	 * @param newMin New minimum.
 	 * @param newMax New maximum.
 	 * @param newVal New value.
 	 */
 	public void setValue(double newMin, double newMax, double newVal)
 	{
 		double old = labelValue;
 		labelValue = newVal;
 		getValueLabel().setValue(newVal);
 		userRangedValue.setValue(newMin, newMax, newVal);
 		firePropertyChange("value", new Double(old), new Double(newVal));
 	}
 
 	/**
 	 * Sets position of value label.
 	 *
 	 * @param p Center point of value label.
 	 */
 	public void setValueLabelPosition(Point p)
 	{
 		getValueLabel().setPosition(p.x, p.y);
 	}
 
 	/**
 	 * Paints the component. This method only paints the gauger from background
 	 * buffer, which is initialized elsewhere. If neccessary, active elements
 	 * such as needle and value label are updated as well.
 	 *
 	 * @param g Context to paint to.
 	 */
 	protected void paintComponent(Graphics g)
 	{
 		clearBuffer();
 		//System.out.println(" SIZE "+getSize());
 		//System.out.println("GSIZE "+g.getClipBounds());
 		try {
 			//if (getTransform() != null) {
 				Graphics2D g2 = (Graphics2D)g;
 				
 				// Rectangle clip = g2.getClipBounds();
 				// Image image = getBuffer().getSubimage(clip.x, clip.y, clip.width, clip.height);
 				g.drawImage(getBuffer(), 0, 0, null);
 				g2.addRenderingHints(PaintHelper.getAntialiasingHints());
 				getNeedle().setTransform(getTransform());
 				getNeedle().render(g2);
 				g2.setColor(getForeground());
 				getValueLabel().draw(g2);
 				
 			//}
 		} catch (Exception e) {
 			// Weird synhronization error has been noticed to occur in this
 			// method.
 		}
 	}
 
 	/**
 	 * Sets scale to logarithmic.
 	 */
 	public void setLogarithmicScale()
 	{	
 		userRangedValue.setRange(new LogarithmicRange()); 
 		repaint();
 	}
 
 	/**
 	 * Sets scale to linear.
 	 */
 	public void setLinearScale()
 	{
 		userRangedValue.setRange(new LinearRange()); 
 		repaint();
 	}
 
 	/**
 	 * Returns whether the scale is logarithmic.
 	 *
 	 * @return True if scale is logarithmic.
 	 */
 	public boolean isLogarithmicScale()
 	{
 		return userRangedValue.getRange() instanceof LogarithmicRange;
 	}
 
 	/**
 	 * Returns whether the scale is linear.
 	 *
 	 * @return True if scale is linear.
 	 */
 	public boolean isLinearScale()
 	{
 		return userRangedValue.getRange() instanceof LinearRange;
 	}
 
 	/**
 	 * Returns size of tick label when renderer. Return value is ammount in
 	 * pixels. This is the size of label in the direction along the scale.
 	 *
 	 * @see com.cosylab.gui.components.range.TickCallback#measureTick(double,
 	 *      String)
 	 */
 	public int measureTick(double position, String text)
 	{
 		return getTransform().measureTick(getBuffer().getGraphics(), position,
 		    text);
 
 		//		int w = getBuffer().getGraphics().getFontMetrics().stringWidth(text);
 		//		int x = (int)(getTransform().scaleWidth(0.7) * position);
 		//		return new TickSize(x - w / 2, w);
 	}
 
 	/**
 	 * Returns popup manager for adding popup actions.
 	 *
 	 * @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("Capture screen...") {
 				private static final long serialVersionUID = 1L;
 				public void actionPerformed(ActionEvent e)
 				{
 					ScreenCapturer sc = new ScreenCapturer(Gauger.this);
 					sc.showScreenDialog();
 				
 				}
 			});
 		}
 
 		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);
 	}
 
 	/**
 	 * Returns the Customizer intance for this displayer.
 	 *
 	 * @return the Customizer intance for this displayer
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 		return customizer;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateOriginator#getState()
 	 */
 	public State getState()
 	{
 		State s = StateFactory.createState();
 		s.putDouble("Min", getMinimum());
 		s.putDouble("Max", getMaximum());
 		s.putString("Format", getFormat());
 		s.putString("Units", getUnits());
 		s.putBoolean("LogarithmicScale", isLogarithmicScale());
 		s.putBoolean("LinearScale", isLinearScale());
 		s.putInt("ScaleMode", getScaleMode());
 		s.putFont("Font", getValueLabelFont());
 
 		return s;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateOriginator#setState(com.cosylab.application.state.State)
 	 */
 	public void setState(State state)
 	{
 		setMinimum(state.getDouble("Min", getMinimum()));
 		setMaximum(state.getDouble("Max", getMaximum()));
 		setFormat(state.getString("Format", getFormat()));
 		setUnits(state.getString("Units", getUnits()));
 
 		if (state.getBoolean("LogarithmicScale", false)) {
 			setLogarithmicScale();
 		}
 
 		if (state.getBoolean("LinearScale", false)) {
 			setLinearScale();
 		}
 
 		setScaleMode(state.getInt("ScaleMode", getScaleMode()));
 		setValueLabelFont(state.getFont("Font"));
 	}
 	
 	/**
 	 * Sets the font used to display tick labels.
 	 *
 	 * @param tickText Font for tick labels.
 	 */
 	public void setTickTextFont(Font tickText)
 	{
 		Font oldValue = getTickTextFont();
 		this.tickTextFont = tickText;
 		firePropertyChange("tickTextFont", oldValue, tickText);
 	}
 
 	/**
 	 * Returns font used to display tick labels.
 	 *
 	 * @return Current font for ticks.
 	 */
 	public Font getTickTextFont()
 	{
 		return tickTextFont;
 	}
 
 	/**
 	 * Returns color of scale background.
 	 *
 	 * @return Color of scale background.
 	 */
 	public Color getScaleColor()
 	{
 		return scaleColor;
 	}
 
 	/**
 	 * Sets color of scale background.
 	 *
 	 * @param newScaleColor Color of scale background.
 	 */
 	public void setScaleColor(Color newScaleColor)
 	{
 		Color oldValue = getScaleColor();
 		scaleColor = newScaleColor;
 		firePropertyChange("scaleColor", oldValue, newScaleColor);
 	}
 
 	/**
 	 * Returns the color of the needle.
 	 *
 	 * @return Color of needle.
 	 */
 	public Color getNeedleColor()
 	{
 		return needleColor;
 	}
 	
 
 	/**
 	 * Sets the color of the needle.
 	 *
 	 * @param newNeedleColor New color of needle.
 	 */
 	public void setNeedleColor(Color newNeedleColor)
 	{
 		Color oldValue = getNeedleColor();
 		needleColor = newNeedleColor;
 		firePropertyChange("needleColor", oldValue, newNeedleColor);
 	}
 
 	/**
 	 * Returns font for value label.
 	 *
 	 * @return Font for value label.
 	 */
 	public Font getValueLabelFont()
 	{
 		return valueLabelFont;
 	}
 
 	/**
 	 * Sets font for value label.
 	 *
 	 * @param value New font for value label.
 	 */
 	public void setValueLabelFont(Font value)
 	{
 		Font oldValue = getValueLabelFont();
 		valueLabelFont = value;
 		firePropertyChange("valueLabelFont", oldValue, value);
 	}
 	
 	/**
 	 * Sets the low warning limit. The limit should be given in percentage of
 	 * the current span of the gauger.
 	 * 
 	 * @param v new low warning limit
 	 */
 	public void setLowWarningLimit(double v){
 		double oldValue = getLowWarningLimit();
 		lowWarningLimit = v;
 		firePropertyChange("lowWarningLimit", oldValue, v);
 	}
 	
 	/**
 	 * Returns the low warning limit.
 	 * 
 	 * @return low warning limit
 	 */
 	public double getLowWarningLimit(){
 		return lowWarningLimit;
 	}
 	
 	/**
 	 * Sets the low alarm limit. The limit should be given in percentage of
 	 * the current span of the gauger.
 	 * 
 	 * @param v new low alarm limit.
 	 */
 	public void setLowAlarmLimit(double v){
 		double oldValue = getLowAlarmLimit();
 		lowAlarmLimit = v;
 		firePropertyChange("lowAlarmLimit", oldValue, v);
 	}
 	
 	/**
 	 * Returns the low alarm limit.
 	 * 
 	 * @return low alarm limit
 	 */
 	public double getLowAlarmLimit(){
 		return lowAlarmLimit;
 	}
 	
 	/**
 	 * Sets the high warning limit. The limit should be given in percentage of
 	 * the current span of the gauger.
 	 * 
 	 * @param v new high warning limit
 	 */
 	public void setHighWarningLimit(double v){
 		double oldValue = getHighWarningLimit();
 		highWarningLimit = v;
 		firePropertyChange("highWarningLimit", oldValue, v);
 	}
 	
 	/**
 	 * Returns the high warning limit.
 	 *  
 	 * @return high warning limit
 	 */
 	public double getHighWarningLimit(){
 		return highWarningLimit;
 	}
 	
 	/**
 	 * Sets the high alarm limit. The limit should be given in percentage of
 	 * the current span of the gauger.
 	 * 
 	 * @param v new high alarm limit
 	 */
 	public void setHighAlarmLimit(double v){
 		double oldValue = getHighAlarmLimit();
 		highAlarmLimit = v;
 		firePropertyChange("highAlarmLimit", oldValue, v);
 	}
 	
 	/**
 	 * Returns the high alarm limit.
 	 * 
 	 * @return high alarm limit
 	 */
 	public double getHighAlarmLimit(){
 		return highAlarmLimit;
 	}
 	
 	/**
 	 * Returns the color which indicates the alarm status.
 	 * 
 	 * @return the alarmColor.
 	 */
 	public Color getAlarmColor() {
 		return alarmColor;
 	}
 
 	/**
 	 * Sets the color which indicates the alarm status.
 	 * 
 	 * @param alarmColor new alarm color
 	 */
 	public void setAlarmColor(Color alarmColor) {
 		Color oldValue = getAlarmColor();
 		this.alarmColor = alarmColor;
 		firePropertyChange("alarmColor", oldValue, alarmColor);
 	}
 
 	/**
 	 * Returns the color which indicates out of bounds status.
 	 * 
 	 * @return the outOfBoundsColor.
 	 */
 	public Color getOutOfBoundsColor() {
 		return outOfBoundsColor;
 	}
 
 	/**
 	 * Sets the color which indicates out of bounds status.
 	 * 
 	 * @param outOfBoundsColor new out of bounds color
 	 */
 	public void setOutOfBoundsColor(Color outOfBoundsColor) {
 		Color oldValue = getOutOfBoundsColor();
 		this.outOfBoundsColor = outOfBoundsColor;
 		firePropertyChange("outOfBoundsColor", oldValue, outOfBoundsColor);
 	}
 
 	/**
 	 * Returns the color which indicates warning status.
 	 * 
 	 * @return the warningColor.
 	 */
 	public Color getWarningColor() {
 		return warningColor;
 	}
 
 	/**
 	 * Sets the color which indicates the warning status.
 	 * 
 	 * @param warningColor new warning color
 	 */
 	public void setWarningColor(Color warningColor) {
 		Color oldValue = getWarningColor();
 		this.warningColor = warningColor;
 		firePropertyChange("warningColor", oldValue, warningColor);
 	}
 
 	// --------- methods below do not have any effect on the behaviour ------
 	/**
 	 * Returns the title of this widget.
 	 * 
 	 * @return
 	 */
 	protected String getTitle() {
 		return title;
 	}
 
 	/**
 	 * Sets the title of this widget.
 	 * 
 	 * @param title
 	 */
 	protected void setTitle(String title) {
 		String oldValue = getTitle();
 		this.title = title;
 		firePropertyChange("title", oldValue, title);
 	}
 
 	/**
 	 * Returns true is title is visible.
 	 * 
 	 * @return
 	 */
 	protected boolean isTitleVisible() {
 		return titleVisible;
 	}
 
 	/**
 	 * Sets the title visible/invisible.
 	 * 
 	 * @param titleVisible
 	 */
 	protected void setTitleVisible(boolean titleVisible) {
 		if (this.titleVisible == titleVisible) return;
 		this.titleVisible = titleVisible;
 		firePropertyChange("titleVisible", !titleVisible, titleVisible);
 	}
 
 	protected boolean isResizable() {
 		return resizable;
 	}
 
 	protected void setResizable(boolean resizable) {
 		if (this.resizable == resizable) return;
 		this.resizable = resizable;
 		firePropertyChange("resizable", !resizable, resizable);
 	}
 
 	/**
 	 * Returns the maximum allowed font size of the title.
 	 * 
 	 * @return title maximum font size
 	 */
 	protected int getTitleMaximumFontSize() {
 		return titleMaximumFontSize;
 	}
 
 	/**
 	 * Sets the maximum allowed font size of the title.
 	 * 
 	 * @param titleMaximumFontSize new maximum font size
 	 */
 	protected void setTitleMaximumFontSize(int titleMaximumFontSize) {
 		int oldValue = getTitleMaximumFontSize();
 		this.titleMaximumFontSize = titleMaximumFontSize;
 		firePropertyChange("titleMaximumFontSize", oldValue, titleMaximumFontSize);
 	}
 
 	/**
 	 * Returns the minimum allowed font size of the title.
 	 * 
 	 * @return title minimum font size
 	 */
 	protected int getTitleMinimumFontSize() {
 		return titleMinimumFontSize;
 	}
 
 	/**
 	 * Sets the minimum allowed font size of the title.
 	 * 
 	 * @param titleMinimumFontSize new minimum font size
 	 */
 	protected void setTitleMinimumFontSize(int titleMinimumFontSize) {
 		int oldValue = getTitleMinimumFontSize();
 		this.titleMinimumFontSize = titleMinimumFontSize;
 		firePropertyChange("titleMinimumFontSize", oldValue, titleMinimumFontSize);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickParameters#formatNumber(double)
 	 */
 	public String formatNumber(double x) {
 		return formatter.sprintf(x);
 	}
 	
 	/**
 	 * Simple test method for gauger.
 	 *
 	 * @param args String[]
 	 */
 	public static void main(String[] args)
 	{
 		Thread t = new Thread() {
 				public void run()
 				{
 					javax.swing.JFrame frame = new javax.swing.JFrame();
 					frame.addWindowListener(new WindowAdapter() {
 							public void windowClosing(WindowEvent e)
 							{
 								System.exit(0);
 							}
 						});
 
 					frame.setSize(new java.awt.Dimension(150, 120));
 
 					Gauger sp = new Gauger();
 					sp.setLinearScale();
 					sp.getRangedValue().setTickCalculator(new ManualTickCalculator(new double[]{5,50,100,500}, new double[]{5,50,100,500}, 100));
 					sp.setScaleMode(Gauger.FIXED_SCALE);
 					sp.setValue(-100, 500.0, 0);
 					sp.setUnits("A");
 					sp.setFormat("%d");
 					frame.setContentPane(sp);
 					//frame.show();
 					frame.setVisible(true);
 
 					//double x = 5;
 					int i = 1;
 
 					//long time1 = System.currentTimeMillis();
 					//long time2 = 0;
 					//boolean b= false;
 					while (true) {
 						//time2 = System.currentTimeMillis() - time1;
 						//x = 2.0
 						//	+ NoiseMaker.perlinNoise((double)time2 / 100.0 * Math.PI / 180);
 						sp.setValue(Math.random() * 80 -40 );
 					
 						try {
 							i++;
 
 							if (i > 50) {
 								//	time2 = System.currentTimeMillis();
 								//	delta = time2 - time1;
 								//	time1 = time2;
 								//	System.out.println(i * 1000 / delta + " FPS");
 								i = 0;
 							}
 
 							sleep(500);
 						} catch (Exception e) {
 							e.printStackTrace();
 						}
 					}
 				}
 			};
 
 		t.run();
 	}
 }
 
 /* __oOo__ */