/*
    * 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.Graphics;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusAdapter;
  import java.awt.event.FocusEvent;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.Timer;
  import java.util.TimerTask;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.JFrame;
  import javax.swing.JTextField;
  import javax.swing.border.Border;
  import javax.swing.border.LineBorder;
  import javax.swing.event.DocumentEvent;
  import javax.swing.event.DocumentListener;
  
  import com.cosylab.events.SetEvent;
  import com.cosylab.events.SetListener;
  import com.cosylab.gui.components.numberfield.AbstractNumberDocument;
  import com.cosylab.gui.components.numberfield.AngleNumberDescriptor;
  import com.cosylab.gui.components.numberfield.DefaultNumberDescriptor;
  import com.cosylab.gui.components.numberfield.NumberDescriptor;
  import com.cosylab.gui.components.numberfield.NumberDescriptorDocument;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyUIElements;
  import com.cosylab.gui.components.util.PaintHelper;
  import com.cosylab.logging.DebugLogger;
  
  
  /**
   * Descendant of <code>ResizableTextField</code> which only allows input of
   * numbers. Double and long number formats are supported through number
   * document classes <code>DobuleDocument</code> and <code>LongDocument</code>,
   * both descedents of <code>AbstractNumberDocument</code>, while display
   * format is controlled using <code>com.cosylab.util.PrintfFormat</code>
   * string parser. The number field operates in two modes. When in focus mode,
   * the user can type in numbers that are recognized by the set number document
   * of the number field. When the user presses the <i>Enter</i> key or the
   * component goes out of focus the typed value is checked for range using the
   * set minimum and maximum allowed values. Than the new value is displayed
   * using the <code>com.cosylab.util.PrinfFormat</code> with the set format
   * string. Value stored by the number field can be accessed through getter and
   * setter methods in both <code>double</code> or <code>long</code> or even
   * generic <code>Number</code> type.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   *
   * @see com.cosylab.gui.components.ResizableTextField
   * @see AbstractNumberDocument
   * @see com.cosylab.util.PrintfFormat
   */
  public class NumberField extends ResizableTextField
  {
  	/**
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  
  	/**
  	 * Converts format string to default safe format for appropriate number
  	 * type.
  	 *
  	 * @param numberType number type for which format is created
  	 * @param format old format to be used as reference
  	 *
  	 * @return safe default format
 	 *
 	 * @throws NullPointerException if type is null
 	 */
 	public static String createDefaultFormat(Class<? extends Number> numberType, String format)
 	{
 		if (numberType == null) {
 			throw new NullPointerException("numberType");
 		}
 
 		if (format == null) {
 			return createDefaultFormat(numberType);
 		}
 
 		String newFormat = null;
 
 		if (numberType == long.class || numberType == Long.class) {
 			int percIdx = format.indexOf('%');
 			int fltIdx = format.indexOf('f', percIdx);
 
 			if (fltIdx == -1) {
 				fltIdx = format.indexOf('d', percIdx);
 			}
 
 			newFormat = format.substring(0, percIdx + 1)
 				+ (format.charAt(percIdx + 1) == '+' ? "+3d" : "3d")
 				+ format.substring(fltIdx + 1);
 		} else if (numberType == double.class || numberType == Double.class) {
 			int percIdx = format.indexOf('%');
 			int fltIdx = format.indexOf('d', percIdx);
 
 			if (fltIdx == -1) {
 				fltIdx = format.indexOf('f', percIdx);
 			}
 
 			newFormat = format.substring(0, percIdx + 1)
 				+ (format.charAt(percIdx + 1) == '+' ? "+3.2f" : "3.2f")
 				+ format.substring(fltIdx + 1);
 		}
 
 		return newFormat;
 	}
 
 	/**
 	 * Returns safe default format for type.
 	 *
 	 * @param numberType number type
 	 *
 	 * @return default format
 	 *
 	 * @throws NullPointerException if type is null
 	 */
 	public static String createDefaultFormat(Class<? extends Number> numberType)
 	{
 		if (numberType == null) {
 			throw new NullPointerException("numberType");
 		}
 
 		String newFormat = null;
 
 		if ((numberType == long.class) || (numberType == Long.class)) {
 			newFormat = "%+3d";
 		} else if ((numberType == double.class) || (numberType == Double.class)) {
 			newFormat = "%+3.2f";
 		}
 
 		return newFormat;
 	}
 
 	/**
 	 * Listens for action events and handles the focus change.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class NumberActionAdapter implements ActionListener
 	{
 		/**
 		 * Loses focus and notifies SetListeners when action is performed.
 		 *
 		 * @param e ActionEvent
 		 *
 		 * @see java.awt.event.ActionListener#actionPerformed(ActionEvent)
 		 */
 		public void actionPerformed(ActionEvent e)
 		{
 			/* If NumberField is empty, old value should be restored. */
 			if (getText().length()!=0) updateDocumentValue();
 			fireSetPerformed();
 			exitOnAction = true;
 
 			/*Invoked to lose focus*/
 			setEnabled(false);
 			setEnabled(true);
 			staticMode();
 		}
 	}
 
 	/**
 	 * Listens for document events and handles the value property change.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class NumberDocumentAdapter implements DocumentListener
 	{
 		/**
 		 * Updates the Numberfield while the text is typed.
 		 *
 		 * @param e DocumentEvent
 		 *
 		 * @see javax.swing.event.DocumentListener#changedUpdate(javax.swing.event.DocumentEvent)
 		 */
 		public void changedUpdate(DocumentEvent e)
 		{
 			logger.finer(e.toString());
 
 			if (policy == SET_AS_TYPED && editing) {
 				logger.fine("SET_AS_TYPED");
 				updateDocumentValue();
 				fireSetPerformed();
 			}
 		}
 
 		/**
 		 * Updates the Numberfield while the text is typed.
 		 *
 		 * @param e DocumentEvent
 		 *
 		 * @see javax.swing.event.DocumentListener#insertUpdate(javax.swing.event.DocumentEvent)
 		 */
 		public void insertUpdate(DocumentEvent e)
 		{
 			logger.finer(e.toString());
 
 			if (policy == SET_AS_TYPED && editing) {
 				logger.fine("SET_AS_TYPED");
 				setValue(numberDocument.getValue());
 				fireSetPerformed();
 			}
 		}
 
 		/**
 		 * Updates the Numberfield while the text is typed.
 		 *
 		 * @param e DocumentEvent
 		 *
 		 * @see javax.swing.event.DocumentListener#removeUpdate(javax.swing.event.DocumentEvent)
 		 */
 		public void removeUpdate(DocumentEvent e)
 		{
 			logger.finer(e.toString());
 
 			if (policy == SET_AS_TYPED && editing) {
 				logger.fine("SET_AS_TYPED");
 				setValue(numberDocument.getValue());
 				fireSetPerformed();
 			}
 		}
 	}
 
 	/**
 	 * Listens for focus events sets the appropriate display mode.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class NumberFocusAdapter extends FocusAdapter
 	{
 		/**
 		 * Switches to editing mode of the Numberfield when focus is gained.
 		 *
 		 * @param e FocusEvent
 		 *
 		 * @see java.awt.event.FocusListener#focusGained(FocusEvent)
 		 */
 		public void focusGained(FocusEvent e)
 		{
 			if (isEditable()) {
 				editMode();
 
 				int enterPolicy = getEnterPolicy();
 
 				switch (enterPolicy) {
 				case ENTER_AT_END:
 					setCaretPosition(getDocument().getLength());
 
 					break;
 
 				case ENTER_AT_START:
 					setCaretPosition(0);
 
 					break;
 
 				case ENTER_SELECTED:
 					setSelectionStart(0);
 					setSelectionEnd(getDocument().getLength());
 
 					break;
 
 				/*case ENTER_AT_CLICKED :
 				    int idx=0;
 				    if (clickIdx>0) {
 				        idx=clickIdx;
 				        focusHandled=false;
 				    }
 				    setCaretPosition(idx);
 				    break;*/
 				default:
 					break;
 				}
 			}
 		}
 
 		/**
 		 * Updates the Numberfield when focus is lost.
 		 *
 		 * @param e FocusEvent
 		 *
 		 * @see java.awt.event.FocusListener#focusLost(FocusEvent)
 		 */
 		public void focusLost(FocusEvent e)
 		{
 			logger.finer(e.toString());
 
 			if (exitOnAction == true) {
 				exitOnAction = false;
 			} else if (policy == SET_ON_EXIT) {
 				logger.finer("new value " + numberDocument.getValue());
 				
 				setValue(numberDocument.getValue());
 				fireSetPerformed();
 			}
 
 			staticMode();
 			
 			/* If out of bounds warning is on this signals that NumberField has lost focus. */
 			if (warnOutOfBounds) focusLost = true;
 		}
 	}
 
 	/**
 	 * An implementation of KeyAdapter responsible for losing focus when the
 	 * ESC key is pressed.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class NumberKeyAdapter extends KeyAdapter
 	{
 		/**
 		 * Makes the Numberfield lose focus when the ESC key is pressed.
 		 *
 		 * @param e KeyEvent
 		 *
 		 * @see java.awt.event.KeyListener#keyPressed(KeyEvent)
 		 */
 		public void keyPressed(KeyEvent e)
 		{
 			if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
 				/*Invoked to lose focus*/
 				exitOnAction = true;
 				setEnabled(false);
 				setEnabled(true);
 				staticMode();
 			}
 		}
 	}
 
 	/**
 	 * An extension of Timer used for periodic tilting of the Wheelswitch.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 *
 	 */
 	protected class TiltHandler extends Timer
 	{
 		private class TiltTask extends TimerTask
 		{
 			/**
 			 * DOCUMENT ME!
 			 */
 			public void run()
 			{
 				logger.fine("tilting " + numberOfTilts);
 
 				if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 					cancel();
 					tilting = false;
 				} else {
 					numberOfTilts++;
 					tilting = !tilting;
 				}
 				repaint();
 			}
 		}
 
 		private final int MAX_NUMBER_OF_TILTS = 3;
 		private final long TILT_RATE = 200;
 		private int numberOfTilts = MAX_NUMBER_OF_TILTS;
 
 		/**
 		 * Scedules a new tilting task if the user value equals any of the
 		 * bounds.
 		 */
 		public void tilt()
 		{
 			if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 				numberOfTilts = 0;
 				logger.info("scheduling tilting");
 				schedule(new TiltTask(), 0, TILT_RATE);
 			} else {
 				numberOfTilts = 0;
 			}
 		}
 	}
 
 	private final Logger logger = DebugLogger.getLogger("NF", Level.OFF);
 
 	/** Setting policy name tag. */
 	public static final String SETTING_POLICY = "settingPolicy";
 
 	/** Setting policy - value set as typed. */
 	public static final int SET_AS_TYPED = 0;
 
 	/** Setting policy - value set on apply. */
 	public static final int SET_ON_APPLY = 1;
 
 	/** Setting policy - value set when focus is lost. */
 	public static final int SET_ON_EXIT = 2;
 
 	/** Enter policy name tag. */
 	public static final String ENTER_POLICY = "enterPolicy";
 
 	/** Enter policy - enter at clicked position. */
 	public static final int ENTER_AT_CLICKED = 0;
 
 	/** Enter policy -  */
 	public static final int ENTER_SELECTED = 1;
 
 	/** Enter policy - enter at the end of existing value. */
 	public static final int ENTER_AT_END = 2;
 
 	/** Enter policy - enter at the beginning of existing value. */
 	public static final int ENTER_AT_START = 3;
 
 	/** Value property name tag. */
 	public static final String VALUE = "value";
 
 	/** Number type property name tag. */
 	public static final String NUMBER_TYPE = "numberType";
 	private NumberDescriptorDocument numberDocument;
 	private Class<? extends Number> numberType;
 	private Number maximum;
 	private Number minimum;
 	private Number value;
 	private NumberDocumentAdapter numberDocumentHandler;
 
 	//private PlainDocument plainDocument;
 	private String format = null;
 	private TiltHandler tiltHandler;
 	private boolean editing;
 	private boolean exitOnAction = false;
 	private boolean tilting;
 	private boolean tiltingEnabled;
 	private NumberDescriptor numberDescriptor = null;
 	
 	/*
 	 * The following fields are used for signaling that the value of this 
 	 * component is out of bounds. 
 	 */
 	
 	/* Defines if NumberField should signal that the value is out of bounds. */
 	private boolean warnOutOfBounds = false;
 	/* Signals that the value of this NumberField is currently out of bounds. */
 	private boolean outOfBounds = false;
 	/* Signals that this component has lost focus. */
 	private boolean focusLost = false;
 	/* Signals that the value of this NumberField has changed. */
 	private boolean valueChanged = false;
 	/* Value displayed by this component while being edited. */
 	private Number userInput = null;
 	/* Background colors. */
 	private Color normalColor = this.getBackground();
 	private Color warningColor = new Color(255, 200, 200);
 	private Color outOfBoundsColor = new Color(255, 100, 100);
 
 	private int policy = SET_ON_EXIT;
 
 	/**
 	 * Constructs a new NumberField with specified value and PrintfFormat
 	 * format string.
 	 *
 	 * @param newValue initial value (null not permitted)
 	 * @param newFormat initial format (null not permitted)
 	 *
 	 * @throws IllegalArgumentException if value or format is null
 	 */
 	public NumberField(Number newValue, String newFormat)
 	{
 		super();
 
 		if (newValue == null) {
 			throw new IllegalArgumentException("number value");
 		}
 
 		if (newFormat == null) {
 			throw new IllegalArgumentException("format");
 		}
 
 		value = newValue;
 
 		format = newFormat;
 
 		//plainDocument = new PlainDocument();
 		numberDocument = new NumberDescriptorDocument();
 		numberDocumentHandler = new NumberDocumentAdapter();
 		numberDocument.addDocumentListener(numberDocumentHandler);
 
 		setDocument(numberDocument);
 
 		setNumberType(newValue.getClass());
 		setFormat(newFormat);
 		
 		setStaticBorder(CosyUIElements.getFlushBorder());
 		setEditBorder(new LineBorder(ColorHelper.getFocus(), 2));
 		setEnterPolicy(ENTER_AT_CLICKED);
 
 		addFocusListener(new NumberFocusAdapter());
 		addActionListener(new NumberActionAdapter());
 		addKeyListener(new NumberKeyAdapter());
 		staticMode();
 	}
 
 	/**
 	 * Constructs a new NumberField with value.
 	 *
 	 * @param newValue initial value
 	 */
 	public NumberField(Number newValue)
 	{
 		this(newValue, createDefaultFormat(newValue.getClass()));
 	}
 
 	/**
 	 * Default constructor for NumberField creates number field with zero
 	 * value.
 	 */
 	public NumberField()
 	{
 		this(new Double(0), createDefaultFormat(Double.class));
 	}
 
 	/**
 	 * Sets the value of type <code>doubleValue</code> to be displayed.
 	 *
 	 * @param newValue
 	 */
 	public void setDoubleValue(double newValue)
 	{
 		logger.info("new value " + newValue);
 
 		double oldValue = getDoubleValue();
 
 		if (oldValue == newValue) {
 			return;
 		}
 
 		internalSetValue(new Double(newValue));
 
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange("doubleValue", oldValue, newValue);
 		firePropertyChange(VALUE, oldValue, newValue);
 	}
 
 	/**
 	 * Returns the value of type <code>doubleValue</code>
 	 *
 	 * @return doubleValue
 	 */
 	public double getDoubleValue()
 	{
 		return value.doubleValue();
 	}
 
 	/**
 	 * Sets the edit border. Edit border is visible around the input field
 	 * when editing value.
 	 *
 	 * @param border new edit border
 	 */
 	public void setEditBorder(Border border)
 	{
 		super.putClientProperty("editBorder", border);
 	}
 
 	/**
 	 * Returns the edit border.
 	 *
 	 * @return edit border
 	 */
 	public Border getEditBorder()
 	{
 		return (Border)super.getClientProperty("editBorder");
 	}
 
 	/**
 	 * Sets the enter policy. Enter policy specifies where the
 	 * numbers will be entered once the user clicks on the displayer. Available policies:
 	 * <ul>
 	 * <li><code>{@link #ENTER_AT_CLICKED}</code> number will be entered at the 
 	 * place where the user clicked</li>
 	 * <li><code>{@link #ENTER_AT_END}</code> number will be appended to the existing
 	 * value</li>
 	 * <li><code>{@link #ENTER_AT_START}</code> number will be prepended to the
 	 * existing value<li>
 	 * <li><code>{@link #ENTER_SELECTED}</code> number will overwrite the existing
 	 * value</li>
 	 * </ul> 
 	 *
 	 * @param policy new policy
 	 */
 	public void setEnterPolicy(int policy)
 	{
 		super.putClientProperty(ENTER_POLICY, new Integer(policy));
 	}
 
 	/**
 	 * Returns the current enter policy.
 	 *
 	 * @return enter policy
 	 */
 	public int getEnterPolicy()
 	{
 		return ((Integer)super.getClientProperty(ENTER_POLICY)).intValue();
 	}
 
 	/**
 	 * Sets the display format. Acceptsint standard format control strings.
 	 *
 	 * @param newFormat java.lang.String
 	 *
 	 * @throws IllegalArgumentException DOCUMENT ME!
 	 *
 	 * @see com.cosylab.util.PrintfFormat
 	 */
 	public void setFormat(String newFormat)
 	{
 		if (newFormat == null) {
 			throw new IllegalArgumentException("format");
 		}
 
 		String oldFormat = getFormat();
 
 		if (oldFormat.equals(newFormat)) {
 			return;
 		}
 		
 		logger.info("New format '"+newFormat+"'");
 
 		format = newFormat;
 		getNumberDescriptor().setFormat(newFormat);
 		firePropertyChange("format", oldFormat, newFormat);
 
 		if (!editing) {
 			staticMode();
 		}
 	}
 
 	/**
 	 * Returns the diplay format
 	 *
 	 * @return java.lang.String
 	 */
 	public String getFormat()
 	{
 		return format;
 	}
 
 	/**
 	 * Sets the value of type <code>long</code> to be displayed.
 	 *
 	 * @param newValue
 	 */
 	public void setLongValue(long newValue)
 	{
 		logger.info("new value " + newValue);
 
 		long oldValue = getLongValue();
 
 		if (oldValue == newValue) {
 			return;
 		}
 
 		internalSetValue(new Long(newValue));
 
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange("longValue", oldValue, newValue);
 		firePropertyChange(VALUE, oldValue, newValue);
 	}
 
 	/**
 	 * Returns the value of type <code>longValue</code>
 	 *
 	 * @return longValue
 	 */
 	public long getLongValue()
 	{
 		return value.longValue();
 	}
 
 	/**
 	 * Sets the maximum allowed value that can be entered in this NumberField.
 	 * Setting maximum to null means no maximum is set. This method does not
 	 * check for validity of the limit. If maximum is set less than minimum
 	 * then no value can be set.
 	 *
 	 * @param newMaximum Number
 	 */
 	public void setMaximum(Number newMaximum)
 	{
 		newMaximum = castNumber(newMaximum);
 		
 		Number oldMaximum = maximum;
 
 		if (((newMaximum == null) && (oldMaximum == null))
 		    || ((newMaximum != null) && newMaximum.equals(oldMaximum))) {
 			return;
 		}
 
 		if ((minimum != null) && (newMaximum != null)
 		    && (((Comparable<Number>)newMaximum).compareTo(minimum) < 0)) {
 			newMaximum = minimum;
 		}
 
 		maximum = newMaximum;
 		internalSetValue(value);
 
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange("maximum", oldMaximum, newMaximum);
 	}
 
 	/**
 	 * Returns the maximum value allowed by this NumberField. Can be null if no
 	 * maximum is set.
 	 *
 	 * @return Number maximum allowed value.
 	 */
 	public Number getMaximum()
 	{
 		return maximum;
 	}
 
 	/**
 	 * Sets the minimum allowed value that can be entered in this NumberField.
 	 * Setting minimum to null means no minimum is set. This method does not
 	 * check for validity of the limit. If maximum is set less than minimum
 	 * then no value can be set.
 	 *
 	 * @param newMinimum Number
 	 */
 	public void setMinimum(Number newMinimum)
 	{
 		newMinimum = castNumber(newMinimum);
 
 		Number oldMinimum = minimum;
 
 		if (((newMinimum == null) && (oldMinimum == null))
 		    || ((newMinimum != null) && newMinimum.equals(oldMinimum))) {
 			return;
 		}
 
 		if ((maximum != null) && (newMinimum != null)
 		    && (((Comparable<Number>)newMinimum).compareTo(maximum) > 0)) {
 			newMinimum = maximum;
 		}
 
 		minimum = newMinimum;
 		internalSetValue(value);
 
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange("minimum", oldMinimum, newMinimum);
 	}
 
 	/**
 	 * Returns the minimum value allowed by this NumberField. Can be null if no
 	 * miminim is set.
 	 *
 	 * @return Number minimum allowed value
 	 */
 	public Number getMinimum()
 	{
 		return minimum;
 	}
 
 	/**
 	 * Sets the number format. If possible, number format is converted to one
 	 * of two supported document types: <code>Long.class</code> of
 	 * <code>Double.class</code>.
 	 *
 	 * @param newNumberFormat
 	 *
 	 * @throws IllegalArgumentException
 	 */
 	public void setNumberType(Class<? extends Number> newNumberFormat)
 		throws IllegalArgumentException
 	{
 		if (newNumberFormat == numberType) {
 			return;
 		}
 
 		if ((newNumberFormat == long.class) || (newNumberFormat == Long.class)
 		    || (newNumberFormat == int.class)
 		    || (newNumberFormat == Integer.class)
 		    || (newNumberFormat == short.class)
 		    || (newNumberFormat == Short.class)) {
 			numberType = Long.class;
 		} else if ((newNumberFormat == double.class)
 		    || (newNumberFormat == Double.class)
 		    || (newNumberFormat == float.class)
 		    || (newNumberFormat == Float.class)) {
 			numberType = Double.class;
 		} else {
 			throw new IllegalArgumentException("Number type '"
 			    + newNumberFormat + "' is not supported.");
 		}
 
 		getNumberDescriptor().setNumberType(numberType);
 		value = castNumber(value);
 
 		//numberDocument.setValue(value);
 		setFormat(createDefaultFormat(numberType, format));
 
 		minimum = castNumber(minimum);
 		maximum = castNumber(maximum);
 
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange(NUMBER_TYPE, null, newNumberFormat);
 	}
 
 	/**
 	 * Returns the number format
 	 *
 	 * @return java.lang.Class
 	 */
 	public Class<? extends Number> getNumberType()
 	{
 		return numberType;
 	}
 
 	/**
 	 * Sets the setting policy of thi Numberdisplayer. SET_AS_TYPED updates the
 	 * Numberfield value when typed. SET_ON_APPLY updates the Numberfield only
 	 * on actionPerformed events (when the user presses ENTER) SET_ON_EXIT
 	 * updates the numberfield when it loses focus
 	 *
 	 * @param newPolicy
 	 *
 	 * @throws IllegalArgumentException DOCUMENT ME!
 	 */
 	public void setSettingPolicy(int newPolicy)
 	{
 		if ((newPolicy != SET_AS_TYPED) && (newPolicy != SET_ON_APPLY)
 		    && (newPolicy != SET_ON_EXIT)) {
 			throw new IllegalArgumentException(SETTING_POLICY);
 		}
 
 		int oldPolicy = policy;
 		policy = newPolicy;
 		firePropertyChange(SETTING_POLICY, oldPolicy, newPolicy);
 	}
 
 	/**
 	 * Returns the currently used seting policy by this Numberfield
 	 *
 	 * @return int currently used setting policy.
 	 */
 	public int getSettingPolicy()
 	{
 		return policy;
 	}
 
 	/**
 	 * Sets the static border. Static border is displayed around the input field when
 	 * the displayer does not have focus.
 	 *
 	 * @param border new static border
 	 */
 	public void setStaticBorder(Border border)
 	{
 		super.putClientProperty("staticBorder", border);
 	}
 
 	/**
 	 * Returns the static border.
 	 *
 	 * @return the static border
 	 */
 	public Border getStaticBorder()
 	{
 		return (Border)super.getClientProperty("staticBorder");
 	}
 
 	/**
 	 * Sets the tilitng enabled property.
 	 *
 	 * @param b whether the component should tilt when value is out of bounds.
 	 */
 	public void setTiltingEnabled(boolean b)
 	{
 		if (tiltingEnabled == b) {
 			return;
 		}
 
 		tiltingEnabled = b;
 		firePropertyChange("tiltingEnabled", !b, b);
 	}
 
 	/**
 	 * Returns whether the component should indicate value out of bounds
 	 * condition by visually tilting its border.
 	 *
 	 * @return boolean
 	 */
 	public boolean isTiltingEnabled()
 	{
 		return tiltingEnabled;
 	}
 	
 	/**
 	 * Sets the value of warnOutOfBounds flag. If true this NumberField signals
 	 * by change of color that displayed value is out of bounds.
 	 * 
 	 * @param b whether this component should change background color if value
 	 * is out of bounds.
 	 */
 	public void setWarnOutOfBounds(boolean b) {
 		warnOutOfBounds = b;
 	}
 	
 	/**
 	 * Sets the numeric value for this component. New value is subject to
 	 * min/max test if any of them is set. If new value does not fall within
 	 * these bounds, setValue will do nothing.
 	 *
 	 * @param newValue Number
 	 */
 	public void setValue(Number newValue)
 	{
 		logger.info("new value " + newValue);
 
 		if (newValue == null) {
 			return;
 		}
 
 		Number oldValue = value;
 
 		if ((oldValue != null) && oldValue.equals(newValue)) {
 			return;
 		}
 
 		internalSetValue(newValue);
 		
 		if (!editing) {
 			staticMode();
 		}
 
 		firePropertyChange(VALUE, oldValue, newValue);
 
 		if (numberType == Long.class) {
 			firePropertyChange("longValue", oldValue, newValue);
 		} else {
 			firePropertyChange("doubleValue", oldValue, newValue);
 		}
 	}
 
 	/**
 	 * Returns generic representation of the value using the
 	 * <code>Number</code> class.
 	 *
 	 * @return java.lang.Number
 	 */
 	public Number getValue()
 	{
 		return value;
 	}
 
 	/**
 	 * Adds a SetListener to the list of listeners receiving events when sets
 	 * are performed on this Numberfield.
 	 *
 	 * @param l listener to be added.
 	 */
 	public void addSetListener(SetListener l)
 	{
 		listenerList.add(SetListener.class, l);
 	}
 
 	/**
 	 * Removes a SetListener from the list of listeners receiving events when
 	 * sets are performed on this Numberfield.
 	 *
 	 * @param l listener to be removed.
 	 */
 	public void removeSetListener(SetListener l)
 	{
 		listenerList.remove(SetListener.class, l);
 	}
 
 	/* (non-Javadoc)
 	 * Overriden for visualisation purposes.
 	 *
 	 * @see com.cosylab.gui.components.ResizableTextField#calculateFontSize(java.awt.Dimension, java.lang.String)
 	 */
 	/*protected int calculateFontSize(Dimension dim, String text)
 	{
 	    try {
 	        return super.calculateFontSize(dim,
 	            plainDocument.getText(0, plainDocument.getLength()));
 	    } catch (Exception e) {
 	        return super.calculateFontSize(dim, text);
 	    }
 	}*/
 	
 	protected void fireSetPerformed()
 	{
 		SetListener[] list = listenerList.getListeners(SetListener.class);
 		SetEvent e = new SetEvent(this, value);
 
 		for (int i = 0; i < list.length; i++) {
 			list[i].setPerformed(e);
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
 	 */
 	protected void paintComponent(Graphics g)
 	{
 		logger.fine("painting");
 		
 		/* If necessary synchronizes background color. */
 		if (warnOutOfBounds && numberDocument.isUpdated()) {
 			defineBackgroundColor();
 		}
 		
 		super.paintComponent(g);
 
 		if (tilting) {
 			PaintHelper.paintRectangle(g, 0, 0, getWidth() - 2,
 			    getHeight() - 2, ColorHelper.getEmergencyOutline(), 2);
 		}
 	}
 	
 	/**
 	 * Defines background color of this component.
 	 * 
 	 * Color needs to be checked and adjusted if value of this NumberField has
 	 * changed, if user edited its contents or this component lost focus. 
 	 *
 	 */
 	private void defineBackgroundColor() {
 		if (valueChanged || focusLost) {
 			if (outOfBounds) this.setBackground(outOfBoundsColor);
 			else this.setBackground(normalColor);
 			valueChanged = false;
 			focusLost = false;
 		}
 		else {
 			userInput = castNumber(getNumberDescriptor().parseNumber(this.getText()));
 			if (
 					(minimum != null && ((Comparable<Number>)minimum).compareTo(userInput) > 0) ||
 					(maximum != null && ((Comparable<Number>)maximum).compareTo(userInput) < 0)
 					) {
 				this.setBackground(warningColor);
 			}
 			else this.setBackground(normalColor);
 		}
 		
 		numberDocument.setUpdated(false);
 	}
 
 	private TiltHandler getTiltHandler()
 	{
 		if (tiltHandler == null) {
 			tiltHandler = new TiltHandler();
 		}
 
 		return tiltHandler;
 	}
 
 	/*    private int calculateDefaultColumns()
 	    {
 	        int val = 1;
 
 	        if ((format != null) && !format.equals("")) {
 	            // index of first digit
 	            int i1 = format.indexOf('%');
 
 	            if (i1 < 0) {
 	                return format.length();
 	            }
 
 	            if ((format.charAt(i1 + 1) == '+')
 	                || (format.charAt(i1 + 1) == '-')) {
 	                i1++;
 	            }
 
 	            if (format.charAt(i1 + 1) == '.') {
 	                i1++;
 	                val = 2;
 	            }
 
 	            int i2 = i1 + 1;
 
 	            for (; i2 < format.length(); i2++) {
 	                if (!Character.isDigit(format.charAt(i2))) {
 	                    break;
 	                }
 	            }
 
 	            if (((i2 - i1) == 1) || (i2 == format.length())) {
 	                return format.length();
 	            }
 
 	            try {
 	                val += Integer.parseInt(format.substring(i1 + 1, i2));
 	            } catch (NumberFormatException e) {
 	                Debug.out(e);
 	            }
 
 	            if (format.charAt(i2) == '.') {
 	                val++;
 
 	                for (i2++; i2 < format.length(); i2++) {
 	                    if (!Character.isDigit(format.charAt(i2))) {
 	                        i2++;
 
 	                        break;
 	                    }
 	                }
 	            }
 
 	            val += (format.length() - i2);
 	        }
 
 	        return val;
 	    }*/
 	private void editMode()
 	{		
 		int cPos = getCaretPosition();
 		
 		//setDocument(numberDocument);
 		Number val = trimValue(value);
 		//Number val = value;
 		
 		setText(getNumberDescriptor().printEditString(val));
 
 		if (!(getStaticBorder() == null && getEditBorder() == null)) {
 			setBorder(getEditBorder());
 		}
 
 		editing = true;
 
 		if (getParent() != null) {
 			getParent().doLayout();
 		}
 
 		if (cPos > getText().length()) {
 			cPos = getText().length();
 		}
 
 		setCaretPosition(cPos);
 	}
 
 	private void internalSetValue(Number newValue)
 	{
 		logger.info("new value " + newValue);
 
 		if (newValue != null) {
 			newValue = castNumber(newValue);
 
 			value = newValue;
 			
 			/*
 			 * If warnOutOfBounds is set, the following checks if value is out 
 			 * of bounds.
 			 */
 			if (warnOutOfBounds) {
 				valueChanged = true;
 				if (
 						(minimum != null && ((Comparable<Number>)minimum).compareTo(value) > 0) ||
 						(maximum != null && ((Comparable<Number>)maximum).compareTo(value) < 0)
 						) {
 					outOfBounds = true;
 				}
 				else {
 					outOfBounds = false;
 				}
 			}
 			
 			//numberDocument.setValue(newValue);
 		}
 	}
 
 	private void staticMode()
 	{
 		if (!isEnabled()) {
 			logger.finest("Not Enabled.");
 			return;
 		}
 
 		logger.fine("executing");
 
 		editing = false;
 
 		//int cPos = getCaretPosition();
 
 		/*if (getDocument() != plainDocument) {
 		    logger.finest("setting document");
 		    setDocument(plainDocument);
 		}*/
 
 		//		problem = false;
 		try {
 			String s = getNumberDescriptor().printString(value);
 
 			/* 
 			 * If statement prevents component from displaying warningColor 
 			 * instead of outOfBoundsColor if user has edited and reentered 
 			 * the same out of bounds value prior to loosing focus.
 			 */
 			if (warnOutOfBounds) setText(s);
 			else if (!s.equals(getText())) {
 				logger.finest("setting text " + s);
 				setText(s);
 			}
 		} catch (IllegalArgumentException iae) {
 			logger.warning("Exception " + iae);
 
 			//setFormat(createDefaultFormat(numberType, getFormat()));
 			//			problem = true;
 			//			setDocument(numberDocument);			
 			//			/			setText(toString(value));
 			//			System.err.println("Invalid format String: " + iae.getMessage());
 		}
 
 		//setDocument(numberDocument);			
 
 		/* seems llike workaround for ResizableTextField, should be handled there
 		if (userColumns < 1) {
 		    int col= calculateDefaultColumns();
 		    if (col!=getColumns())
 		    logger.finest("setting columns to "+);
 		    super.setColumns(calculateDefaultColumns());
 		}*/
 		if (!(getStaticBorder() == null && getEditBorder() == null)) {
 			if (getBorder() != getStaticBorder()) {
 				logger.finest("setting border");
 				setBorder(getStaticBorder());
 			}
 		}
 
 		/* Is this reallly necesary?
 		if (getParent() != null) {
 		    logger.finest("doLayout");
 		    getParent().doLayout();
 		}*/
 		/* why do we need this, if in static mode anyway caret is not visible.
 		 * Besides it is always 0 when this code happens.
 		cPos = Math.min(getDocument().getLength(), cPos);
 		if (cPos != getCaretPosition()) {
 		    logger.finest("setting carret to "+cPos+" from "+getCaretPosition());
 		    setCaretPosition(cPos);
 		}*/
 	}
 
 	private Number trimValue(Number newValue)
 	{
 		if (newValue == null) {
 			return null;
 		}
 
 		Number retVal = castNumber(newValue);
 
 		if ((minimum != null) && (((Comparable<Number>)retVal).compareTo(minimum) < 0)) {
 			retVal = minimum;
 		}
 
 		if ((maximum != null) && (((Comparable<Number>)retVal).compareTo(maximum) > 0)) {
 			retVal = maximum;
 		}
 
 		//retVal = newValue;
 
 		return retVal;
 	}
 
 	private void updateDocumentValue()
 	{
 		logger.fine("entering");
 
 		Number newValue = numberDocument.getValue();
 
 		if (newValue == null) {
 			return;
 		}
 
 		Number val = trimValue(newValue);
 
 		if (!newValue.equals(val) && tiltingEnabled) {
 			getTiltHandler().tilt();
 		}
 
 		setValue(val);
 	}
 
 	/**
 	 * Returns descriptor object, to which visualization of number as strring
 	 * is dlegated.
 	 *
 	 * @return number visualization
 	 */
 	public synchronized NumberDescriptor getNumberDescriptor()
 	{
 		if (numberDescriptor == null) {
 			setNumberDescriptor(new DefaultNumberDescriptor());
 		}
 
 		return numberDescriptor;
 	}
 
 	/**
 	 * When this is set with non-null value, this NumberField uses this
 	 * descriptor to convert Number to string and back. By this user can
 	 * define ovn visualization of Number.
 	 *
 	 * @param numberDescriptor new Number visualization, can be
 	 *        <code>null</code>
 	 */
 	public synchronized void setNumberDescriptor(
 	    NumberDescriptor numberDescriptor)
 	{
 		this.numberDescriptor = numberDescriptor;
 
 		if (numberDescriptor != null) {
 			numberDocument.setDescriptor(numberDescriptor);
 			numberDescriptor.setNumberType(getNumberType());
 			numberDescriptor.setFormat(getFormat());
 		}
 
 		if (!editing) {
 			staticMode();
 		}
 	}
 
 	/**
 	 * Converts provided number to <code>Number</code> instance whose class
 	 * matches current number type.
 	 *
 	 * @param number number to be cast to current number type
 	 *
 	 * @return correct number type
 	 */
 	public Number castNumber(Number number)
 	{
 		if (number == null) {
 			return null;
 		}
 
 		if (numberType == Double.class) {
 			if (number instanceof Double) {
 				return number;
 			}
 
 			return new Double(number.doubleValue());
 		}
 
 		if (number instanceof Long) {
 			return number;
 		}
 
 		return new Long(number.longValue());
 	}
 
 	/**
 	 * @return Returns the normalColor.
 	 */
 	public Color getNormalColor() {
 		return normalColor;
 	}
 
 	/**
 	 * @param normalColor The normalColor to set.
 	 */
 	public void setNormalColor(Color normalColor) {
 		Color oldValue = getNormalColor();
 		this.normalColor = normalColor;
 		firePropertyChange("normalColor", oldValue, normalColor);
 	}
 
 	/**
 	 * @return Returns the outOfBoundsColor.
 	 */
 	public Color getOutOfBoundsColor() {
 		return outOfBoundsColor;
 	}
 
 	/**
 	 * @param outOfBoundsColor The outOfBoundsColor to set.
 	 */
 	public void setOutOfBoundsColor(Color outOfBoundsColor) {
 		Color oldValue = getOutOfBoundsColor();
 		this.outOfBoundsColor = outOfBoundsColor;
 		firePropertyChange("outOfBoundsColor", oldValue, outOfBoundsColor);
 	}
 
 	/**
 	 * @return Returns the warningColor.
 	 */
 	public Color getWarningColor() {
 		return warningColor;
 	}
 
 	/**
 	 * @param warningColor The warningColor to set.
 	 */
 	public void setWarningColor(Color warningColor) {
 		Color oldValue = getWarningColor();
 		this.warningColor = warningColor;
 		firePropertyChange("warningColor", oldValue, warningColor);
 	}
 
 	
 	/**
 	 * Returns the warnOutOfBounds.
 	 * @return Returns the warnOutOfBounds.
 	 */
 	public boolean isWarnOutOfBounds() {
 		return warnOutOfBounds;
 	}
 	
 	/**
 	 * For testing and demonstration purposes.
 	 *
 	 * @param args String[]
 	 */
 	public static void main(String[] args)
 	{
 		JFrame frame = new JFrame();
 		frame.setSize(340, 300);
 
 		final NumberField field = new NumberField(new Long(12));
 
 		//field.setMaximum(new Integer(Integer.MAX_VALUE));
 		field.setMaximum(new Long(100));
 		field.setMinimum(new Long(0));
 		field.setNumberType(Long.class);
 		field.setValue(new Integer(20));
 		field.setResizable(true);
 		field.setTiltingEnabled(true);
 		field.setNumberDescriptor(new AngleNumberDescriptor());
 		//field.setNumberDescriptor(new DefaultNumberDescriptor());
 
 		field.addPropertyChangeListener(new PropertyChangeListener() {
 				public void propertyChange(PropertyChangeEvent evt)
 				{
 					//System.out.println("P> " + evt.getPropertyName() + " "
 					//    + evt.getNewValue());
 				}
 			});
 		field.addSetListener(new SetListener() {
 				public void setPerformed(SetEvent e)
 				{
 					System.out.println("S> " + e.getValue());
 				}
 			});
 		field.setSettingPolicy(SET_AS_TYPED);
 		frame.getContentPane().setLayout(new GridBagLayout());
 		frame.getContentPane().add(new JTextField(),
 		    new GridBagConstraints(0, 0, 1, 1, 1.0, 1.0,
 		        GridBagConstraints.CENTER, GridBagConstraints.BOTH,
 		        new Insets(15, 15, 15, 15), 0, 0));
 		frame.getContentPane().add(field,
 		    new GridBagConstraints(0, 1, 1, 1, 1.0, 1.0,
 		        GridBagConstraints.CENTER, GridBagConstraints.BOTH,
 		        new Insets(15, 15, 15, 15), 0, 0));
 		frame.addWindowListener(new WindowAdapter() {
 				public void windowClosing(WindowEvent e)
 				{
 					System.exit(0);
 				}
 			});
 		frame.setVisible(true);
 	}
 	
 }
 
 /* __oOo__ */