/*
    * 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 com.cosylab.events.SetEvent;
  import com.cosylab.events.SetListener;
  
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.ScreenCapturer;
  import com.cosylab.gui.components.wheelswitch.AbstractWheelswitchFormatter;
  import com.cosylab.gui.components.wheelswitch.Digit;
  import com.cosylab.gui.components.wheelswitch.StaticDigit;
  import com.cosylab.gui.components.wheelswitch.UpDownButton;
  import com.cosylab.gui.components.wheelswitch.ValueDigit;
  import com.cosylab.gui.components.wheelswitch.WheelswitchFormatter;
  import com.cosylab.gui.components.wheelswitch.WheelswitchLayout;
  
  import com.cosylab.util.Debug;
  
  import java.awt.BorderLayout;
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseWheelEvent;
  import java.awt.event.MouseWheelListener;
  
  import java.util.ArrayList;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.swing.AbstractAction;
  import javax.swing.Box;
  import javax.swing.JButton;
  import javax.swing.JFrame;
  import javax.swing.JPanel;
  import javax.swing.SwingUtilities;
  import javax.swing.event.EventListenerList;
  
  
  /**
   * Descedant of <code>javax.swing.JPanel</code> that contains a row of digits
   * and optionally a two way up-down buttons. It can be used for displaying and
   * modifying a single formatted <code>double</code> value with an optional
   * unit string (also in digits) displyed next to the value. Value manipulation
   * and display formatting is handled by the <code>WheelswitchFormatter</code>.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   *
   * @see Digit
   * @see WheelswitchFormatter
   */
  public class Wheelswitch extends JPanel implements PopupManageable
  {
  	private static final long serialVersionUID = 1L;
  
  	/**
  	 * An implementation of KeyListener used for handling
  	 * key commands for the wheelswitch.
  	 *
  	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
  	 * @version $id$
  	 */
  	protected class KeyHandler extends KeyAdapter
  	{
  		/**
  		 * Updates the digits in this Wheelswitch when key is pressed.
  		 *
  		 * @param e
  		 */
  		public void keyPressed(KeyEvent e)
  		{
  			if (editable && isEnabled()) {
  				if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
  //					Ike's FR by jbobnar RT#41405
 					setSelectedDigit(-1);
 					e.consume();
 					return;
 				}
 				int i = getSelectedDigit();
 
 				if (i >= 0) {
 					if ((e.getKeyChar() >= '0') && (e.getKeyChar() <= '9')) {
 						setDigitValue(i,
 						    Integer.parseInt(String.valueOf(e.getKeyChar())));
 						setSelectedDigit(INCREASE_SELECTION);
 					} else if (e.getKeyCode() == KeyEvent.VK_UP) {
 						setDigitValue(i, ValueDigit.INCREASE_VALUE);
 					} else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
 						setDigitValue(i, ValueDigit.DECREASE_VALUE);
 					} else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
 						setSelectedDigit(INCREASE_SELECTION);
 					} else if ((e.getKeyCode() == KeyEvent.VK_LEFT)
 					    || (e.getKeyCode() == KeyEvent.VK_BACK_SPACE)) {
 						setSelectedDigit(DECREASE_SELECTION);
 					}
 				} else {
 					setSelectedDigit(0);
 				}
 			}
 		}
 	}
 
 	/**
 	 * An implementation of KeyListener used for handling
 	 * key commands for the wheelswitch.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class MouseHandler extends MouseAdapter
 	{
 		/**
 		 * Updates digit selection in this Wheelswitch when left mouse button
 		 * is pressed.
 		 *
 		 * @param e
 		 */
 		public void mousePressed(MouseEvent e)
 		{
 			if (e.getButton() == MouseEvent.BUTTON1) {
 				int index = digits.indexOf(e.getSource());
 //				Ike's FR by jbobnar RT#41405
 				if (getSelectedDigit() == index) {
 					setSelectedDigit(-1);
 				} else {
 					setSelectedDigit(index);
 				}
 				requestFocusInWindow();
 			}
 		}
 	}
 
 	/**
 	 * An implementation of the MouseWheelListener used for handling
 	 * mouse wheel events inside the wheelswitch.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class WheelSwitchMouseHandler extends MouseAdapter implements MouseWheelListener
 	{
 		/**
 		 * Updates the value of the Wheelswitch when UpDownButton is pressed.
 		 *
 		 * @param e DOCUMENT ME!
 		 */
 		public void mouseWheelMoved(MouseWheelEvent e)
 		{
 			Debug.out("mousewheel");
 
 			if (editable && isEnabled()) {
 				int i = getSelectedDigit();
 
 				if (i >= 0) {
 					if (e.getWheelRotation() > 0) {
 						setDigitValue(i, ValueDigit.DECREASE_VALUE);
 					} else {
 						setDigitValue(i, ValueDigit.INCREASE_VALUE);
 					}
 				}
 			}
 		}
 		
 		//Ike's FR by jbobnar RT#41405
 		@Override
 		public void mousePressed(MouseEvent e) {
 			requestFocus();
 			if (getSelectedDigit() == -1) {
 				if (SwingUtilities.isLeftMouseButton(e)) {
 					if (selectedDigit < 0) {
 						setSelectedDigit(0);
 					}
 				} else if (SwingUtilities.isRightMouseButton(e)) {
 					if (selectedDigit < 0) {
 						setSelectedDigit(digits.size()-1);
 					}
 					
 				}
 			}
 		}
 	}
 
 	/**
 	 * 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
 		{
 			public void run()
 			{
 				if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 					cancel();
 
 					for (int i = 0; i < digits.size(); i++) {
 						(digits.get(i)).setTilting(false);
 					}
 				} else {
 					numberOfTilts++;
 
 					for (int i = 0; i < digits.size(); i++) {
 						(digits.get(i)).setTilting(!(digits.get(i))
 						    .isTilting());
 					}
 				}
 
 				repaint();
 			}
 		}
 
 		//		private AudioClip clip1;
 		//		private AudioClip clip2;
 		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 ((formatter.getValue() < formatter.getMaximum())
 			    && (formatter.getValue() > formatter.getMinimum())
 			    || !tiltingEnabled) {
 				//	would be a nice demonstration feature
 				//					if (enhanced && clip1==null) {
 				//						clip1 = 	Applet.newAudioClip(ClassLoader.getSystemResource("tick.wav"));
 				//					}        
 				//					if (enhanced) clip1.play();
 				return;
 			}
 
 			//			would be a nice demonstration feature
 			//			if (enhanced && clip2==null) {
 			//				clip2 = 	Applet.newAudioClip(ClassLoader.getSystemResource("error.wav"));
 			//			}
 			//			if (enhanced) clip2.play();
 			if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 				numberOfTilts = 0;
 				schedule(new TiltTask(), 0, TILT_RATE);
 			} else {
 				numberOfTilts = 0;
 			}
 		}
 	}
 
 	/**
 	 * An implementation of ActionListener used for handling
 	 * events from the up-down button in the wheelswitch.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 */
 	protected class UpDownActionHandler implements ActionListener
 	{
 		/**
 		 * Updates the value of the Wheelswitch when UpDownButton is pressed.
 		 *
 		 * @param e
 		 */
 		public void actionPerformed(ActionEvent e)
 		{
 			if (editable && isEnabled()) {
 				int i = getSelectedDigit();
 
 				if (i >= 0) {
 					int value = 0;
 
 					if (e.getSource() == getUpDownButton().getUpButton()) {
 						value = ValueDigit.INCREASE_VALUE;
 					}
 
 					if (e.getSource() == getUpDownButton().getDownButton()) {
 						value = ValueDigit.DECREASE_VALUE;
 					}
 
 					setDigitValue(i, value);
 				} else {
 					// Jernej should tell if this is OK
 					//setSelectedDigit(digits.size() - 1);
 					// jkamenik: No, Not OK. 
 					// This would select the exponent in exponential format causing havoc!
 					// The setting below is consistent with key behavior.
 					setSelectedDigit(0);
 				}
 
 				//requestFocusInWindow();
 			}
 		}
 	}
 
 	protected static int INCREASE_SELECTION = -11;
 	protected static int DECREASE_SELECTION = -12;
 
 	/** Tag for value property. */
 	public static final String VALUE = "value";
 
 	/** Tag for editable property */
 	public static final String EDITABLE = "editable";
 	protected EventListenerList listenerList = null;
 	protected KeyHandler keyHandler;
 	protected MouseHandler mouseHandler;
 	protected TiltHandler tiltHandler;
 	protected WheelSwitchMouseHandler handler;
 	private Dimension minimumSize = null;
 	private Dimension preferredSize = null;
 	private java.util.List<Digit> digits;
 	private java.util.List<Digit> unitDigits;
 	private java.util.List<Digit> hiddenDigits;
 	private UpDownButton upDownButton;
 	private AbstractWheelswitchFormatter formatter;
 	private boolean editable = true;
 	private PopupManager popupManager;
 	private boolean popupEnabled;
 	private boolean enhanced = true;
 	private boolean animated = false;
 	private boolean tiltingEnabled;
 	private int selectedDigit = -1;
 	private ResizableTextLabel unitLabel;
 	private boolean debug = false;
 	private boolean unitSeparate = false;
 	private boolean digitsTakeUpAllSpace = true;
 	private int numberOfAllDigits = 10;
 
 	/**
 	 * Constant string representing the property name of horizontal alignment.
 	 */
 	public static final String HORIZONTAL_ALIGNMENT = "horizontalAlignment";
 
 	/**
 	 * Constructor for <code>Wheelswitch</code> creates a new Wheelswitch with
 	 * the specified value, format and unit. No minimum or maximum values are
 	 * set.
 	 *
 	 * @param newFormat
 	 * @param newValue
 	 * @param newUnit
 	 */
 	public Wheelswitch(String newFormat, double newValue, String newUnit)
 	{
 		super();
 		listenerList = new EventListenerList();
 		mouseHandler = new MouseHandler();
 		keyHandler = new KeyHandler();
 		tiltHandler = new TiltHandler();
 		handler = new WheelSwitchMouseHandler();
 
 		digits = new ArrayList<Digit>();
 		unitDigits = new ArrayList<Digit>();
 		hiddenDigits = new ArrayList<Digit>();
 
 
 		this.formatter = new WheelswitchFormatter(newFormat);
 		this.formatter.setUnit(newUnit);
 		this.formatter.setValue(newValue);
 
 		addKeyListener(keyHandler);
 		addMouseWheelListener(handler);
 		getUpDownButton().addMouseListener(handler);
 		addMouseListener(handler);
 
 		setFocusable(true);
 		setBackground(ColorHelper.getCosyControl());
 		setLayout(new WheelswitchLayout());
 
 		setupValueDigits();
 		setupUnitDigits();
 		setupLayout();
 		validate();
 		repaint();
 		setPopupEnabled(true);
 	}
 	
 	private UpDownButton getUpDownButton() {
 		if (upDownButton == null) {
 			upDownButton = new UpDownButton();
 			upDownButton.setName("upDownButton");
 			upDownButton.getUpButton().addActionListener(new UpDownActionHandler());
 			upDownButton.getDownButton().addActionListener(new UpDownActionHandler());
 			upDownButton.addKeyListener(keyHandler);
 			upDownButton.setEnabled(false);
 		}
 		return upDownButton;
 	}
 	
 	private ResizableTextLabel getUnitLabel() {
 		if (unitLabel == null) {
 			unitLabel = new ResizableTextLabel();
 			unitLabel.setResizable(true);
 			unitLabel.setEnhanced(enhanced);
 		}
 
 		return unitLabel;
 	}
 
 	/*
 	 * (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("Capture screen...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						ScreenCapturer sc = new ScreenCapturer(Wheelswitch.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);
 	}
 
 	/**
 	 * Constructor for <code>Wheelswitch</code> setting only the value. No
 	 * format or unit are set.
 	 *
 	 * @param newValue
 	 *
 	 * @see #Wheelswitch(String, double, String)
 	 */
 	public Wheelswitch(double newValue)
 	{
 		this(null, newValue, null);
 	}
 
 	/**
 	 * Constructor for Wheelswitch which sets no format or unit and the value
 	 * is set to zero.
 	 *
 	 * @see #Wheelswitch(String, double, String)
 	 */
 	public Wheelswitch()
 	{
 		this(null, 0, null);
 	}
 
 	/**
 	 * Sets the editability of the wheelswitch. If true user can edit change the 
 	 * values displayed by wheelswitch.
 	 *
 	 * @param newEditable
 	 */
 	public void setEditable(boolean newEditable)
 	{
 		if (newEditable == editable) {
 			return;
 		}
 
 		boolean oldEditable = editable;
 		editable = newEditable;
 		firePropertyChange(EDITABLE, oldEditable, newEditable);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		setupLayout();
 		validate();
 		repaint();
 	}
 
 	/**
 	 * Returns whether the wheelswitch can be edited by the user.
 	 *
 	 * @return boolean
 	 */
 	public boolean isEditable()
 	{
 		return editable;
 	}
 
 	/**
 	 * Sets the enhanced property of the wheelswitch. When enhanced the
 	 * wheelswitch animates its digits when changing the value displayed.
 	 *
 	 * @see com.cosylab.gui.components.wheelswitch.Digit#setEnhanced(boolean)
 	 */
 	public void setEnhanced(boolean enhanced)
 	{
 		if (this.enhanced == enhanced) {
 			return;
 		}
 
 		firePropertyChange("enhanced", this.enhanced, enhanced);
 		this.enhanced = enhanced;
 
 		for (int i = 0; i < digits.size(); i++) {
 			(digits.get(i)).setEnhanced(enhanced);
 		}
 
 		for (int i = 0; i < unitDigits.size(); i++) {
 			(unitDigits.get(i)).setEnhanced(enhanced);
 		}
 
 		getUnitLabel().setEnhanced(enhanced);
 	}
 
 	/**
 	 * Gets the enhancement mode of the <code>Wheelswitch</code>.
 	 *
 	 * @return true if wheelswitch is in enhacement mode
 	 */
 	public boolean isEnhanced()
 	{
 		return enhanced;
 	}
 
 	/**
 	 * Sets the format of the value display. Format style is Wheelswitch
 	 * specific.
 	 *
 	 * @param newFormat new format (null not permitted)
 	 *
 	 * @throws NullPointerException if paraeter is null
 	 *
 	 * @see WheelswitchFormatter#setFormat(String)
 	 */
 	public void setFormat(String newFormat)
 	{
 		if (newFormat == null) {
 			throw new NullPointerException("newFormat");
 		}
 
 		if ((formatter.getFormat() != null)
 		    && formatter.getFormat().equals(newFormat)) {
 			return;
 		}
 
 		String oldFormat = formatter.getFormat();
 
 		try {
 			formatter.setFormat(newFormat);
 		} catch (IllegalArgumentException e) {
 			Debug.out(e);
 
 			return;
 		}
 
 		firePropertyChange("format", oldFormat, newFormat);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		setupValueDigits();
 		setupLayout();
 		validate();
 		repaint();
 	}
 
 	/**
 	 * Gets the format of the display.
 	 *
 	 * @return the format
 	 *
 	 * @see WheelswitchFormatter#getFormat()
 	 */
 	public String getFormat()
 	{
 		return formatter.getFormat();
 	}
 
 	/**
 	 * Sets the maximum allowed value.
 	 *
 	 * @param newValue new maximum
 	 *
 	 * @see WheelswitchFormatter#setMaximum(double)
 	 */
 	public void setGraphMax(double newValue)
 	{
 		double oldValue = formatter.getMaximum();
 
 		if (oldValue == newValue) {
 			return;
 		}
 
 		formatter.setMaximum(newValue);
 
 		firePropertyChange("graphMax", oldValue, newValue);
 
 		checkBounds();
 	}
 
 	/**
 	 * Gets the maximum alowed value.
 	 *
 	 * @return the maximum
 	 *
 	 * @see WheelswitchFormatter#getMaximum()
 	 */
 	public double getGraphMax()
 	{
 		return formatter.getMaximum();
 	}
 
 	/**
 	 * Sets the minimum allowed value.
 	 *
 	 * @param newValue new minimum
 	 *
 	 * @see WheelswitchFormatter#setMinimum(double)
 	 */
 	public void setGraphMin(double newValue)
 	{
 		double oldValue = formatter.getMinimum();
 
 		if (oldValue == newValue) {
 			return;
 		}
 
 		formatter.setMinimum(newValue);
 
 		firePropertyChange("graphMin", oldValue, newValue);
 
 		checkBounds();
 	}
 
 	/**
 	 * Gets the minimum alowed value.
 	 *
 	 * @return the minimum
 	 *
 	 * @see WheelswitchFormatter#getMinimum()
 	 */
 	public double getGraphMin()
 	{
 		return formatter.getMinimum();
 	}
 
 	/**
 	 * Sets the maximum and minimum allowed values. This is a convenient method
 	 * for setting both bounds.
 	 *
 	 * @param max
 	 * @param min
 	 */
 	public void setMaxMin(double max, double min)
 	{
 		setGraphMax(max);
 		setGraphMin(min);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#getMinimumSize()
 	 */
 	public Dimension getMinimumSize()
 	{
 		if (minimumSize == null) {
 			int height = 0;
 			int width = 0;
 
 			for (int i = 0; i < getComponentCount(); i++) {
 				width += getComponent(i).getMinimumSize().width;
 				height = Math.max(height,
 					    getComponent(i).getMinimumSize().height);
 			}
 
 			minimumSize = new Dimension(width, height);
 		}
 
 		return minimumSize;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#getPreferredSize()
 	 */
 	public Dimension getPreferredSize()
 	{
 		if (preferredSize == null) {
 			int height = 0;
 			int width = 0;
 
 			for (int i = 0; i < getComponentCount(); i++) {
 				width += getComponent(i).getPreferredSize().width;
 				height = Math.max(height,
 					    getComponent(i).getPreferredSize().height);
 			}
 
 			preferredSize = new Dimension(width, height);
 		}
 
 		return preferredSize;
 	}
 
 	/**
 	 * Sets the tilitng enabled property. If tiliting is enabled the component
 	 * will tile when out of bounds value is set.
 	 *
 	 * @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 unit to be displayed next to the value.
 	 *
 	 * @param newUnit new units
 	 *
 	 * @see WheelswitchFormatter#setUnit(String)
 	 */
 	public void setUnit(String newUnit)
 	{
 		String oldUnit = formatter.getUnit();
 
 		if (oldUnit == newUnit) {
 			return;
 		}
 
 		formatter.setUnit(newUnit);
 		firePropertyChange("unit", oldUnit, newUnit);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		setupUnitDigits();
 		setupLayout();
 		doLayout();
 		repaint();
 	}
 
 	/**
 	 * Gets the unit displayed next to the value.
 	 *
 	 * @return the units
 	 *
 	 * @see WheelswitchFormatter#getUnit()
 	 */
 	public String getUnit()
 	{
 		return formatter.getUnit();
 	}
 
 	/**
 	 * Sets the value and displays it in the wheelswitch. The method may also
 	 * change the current digit selection if neccessary in order to point to
 	 * the same decimal digit of the displayed value.
 	 *
 	 * @param newValue new value
 	 *
 	 * @see WheelswitchFormatter#setValue(double)
 	 */
 	public void setValue(double newValue)
 	{
 		double oldValue = formatter.getValue();
 
 		if (oldValue == newValue) {
 			return;
 		}
 
 		firePropertyChange(VALUE, oldValue, newValue);
 
 		int oldDigitSelection = getSelectedDigit();
 		int decimalSelection = parseDecimalPosition(oldDigitSelection);
 
 		String oldStringValue = formatter.getString();
 		formatter.setValue(newValue);
 
 		String newStringValue = formatter.getString();
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		process(oldStringValue, newStringValue);
 
 		int newDigitSelection = parseDigitPosition(decimalSelection);
 
 		if ((newDigitSelection < digits.size()) && (newDigitSelection >= 0)) {
 			setSelectedDigit(newDigitSelection);
 		} else {
 			setSelectedDigit(-1);
 		}
 
 		checkBounds();
 
 		//tiltHandler.tilt();
 	}
 
 	private void checkBounds()
 	{
 		if (getValue() > getGraphMax()) {
 			getUpDownButton().setOutOfBounds(1);
 		} else if (getValue() < getGraphMin()) {
 			getUpDownButton().setOutOfBounds(-1);
 		} else {
 			getUpDownButton().setOutOfBounds(0);
 		}
 	}
 
 	/**
 	 * Returns the value displayed by the <code>Wheelswitch</code> and stored by
 	 * the <code>formatter</code>.
 	 *
 	 * @return the value
 	 *
 	 * @see WheelswitchFormatter#getValue()
 	 */
 	public double getValue()
 	{
 		return formatter.getValue();
 	}
 
 	/**
 	 * Adds an <code>SetListener</code> to the array of listeners currently
 	 * registered for listening to the value sets of the
 	 * <code>Wheelswitch</code>. These listeners are notified whenever the
 	 * user sets a new value.
 	 *
 	 * @param l
 	 *
 	 * @see com.cosylab.events.SetListener
 	 */
 	public void addSetListener(SetListener l)
 	{
 		listenerList.add(SetListener.class, l);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setEnabled(boolean)
 	 */
 	public void setEnabled(boolean arg0)
 	{
 		super.setEnabled(arg0);
 
 		setupValueDigits();
 		setupUnitDigits();
 		setupLayout();
 		validate();
 		repaint();
 
 		for (int i = 0; i < digits.size(); i++) {
 			(digits.get(i)).setEnabled(arg0);
 		}
 
 		for (int i = 0; i < unitDigits.size(); i++) {
 			(unitDigits.get(i)).setEnabled(arg0);
 		}
 
 		getUpDownButton().setEnabled(arg0);
 	}
 
 	/**
 	 * Sets the maximum number of value digits allowed to be displayed in the
 	 * wheelswitch. The default value is 0 and is ignored.
 	 *
 	 * @param bound is ignored if less or equal zero.
 	 */
 	public void setMaximumDigits(int bound)
 	{
 		int oldBound = formatter.getMaximumDigits();
 		formatter.setMaximumDigits(bound);
 		firePropertyChange("maximumDigits", oldBound, bound);
 	}
 
 	/**
 	 * Removes an <code>SetListener</code> from the array of listeners
 	 * currently registered for listening to the value sets of the
 	 * <code>Wheelswitch</code>.
 	 *
 	 * @param l
 	 */
 	public void removeSetListener(SetListener l)
 	{
 		listenerList.remove(SetListener.class, l);
 	}
 
 	/**
 	 * Sets the value at the i-th digit
 	 */
 	protected void setDigitValue(int i, int newValue)
 	{
 		if (digits.get(i) instanceof StaticDigit) {
 			return;
 		}
 
 		String oldStringValue = formatter.getString();
 		String newStringValue = oldStringValue;
 
 		//flip increase/decrease for negative values
 		if ((newValue == ValueDigit.INCREASE_VALUE)
 		    || (newValue == ValueDigit.DECREASE_VALUE)) {
 			int expIndex = oldStringValue.indexOf('E');
 
 			if (expIndex == -1) {
 				expIndex = oldStringValue.length();
 			}
 
 			if (((oldStringValue.charAt(0) == '-') && (i < expIndex))
 			    ^ ((i > expIndex) && (expIndex < (oldStringValue.length() - 1))
 			    && (oldStringValue.charAt(expIndex + 1) == '-'))) {
 				if (newValue == ValueDigit.INCREASE_VALUE) {
 					newValue = ValueDigit.DECREASE_VALUE;
 				} else {
 					newValue = ValueDigit.INCREASE_VALUE;
 				}
 			}
 		}
 
 		if ((newValue >= 0) && (newValue <= 9)) {
 			newStringValue = oldStringValue.substring(0, i)
 				+ String.valueOf(newValue) + oldStringValue.substring(i + 1);
 		} else if (newValue == ValueDigit.INCREASE_VALUE) {
 			int j;
 
 			for (j = i;
 			    ((j >= 0) && (oldStringValue.charAt(j) != 'E')
 			    && (oldStringValue.charAt(j) != '+')
 			    && (oldStringValue.charAt(j) != '-') && (newValue != 0));
 			    j--) {
 				if (oldStringValue.charAt(j) == '.') {
 					continue;
 				} else if (oldStringValue.charAt(j) != '9') {
 					newStringValue = newStringValue.substring(0, j)
 						+ String.valueOf(Integer.parseInt(
 						        newStringValue.substring(j, j + 1)) + 1)
 						+ newStringValue.substring(j + 1);
 					newValue = 0;
 				} else {
 					
 					newStringValue = newStringValue.substring(0, j) + "0"
 						+ newStringValue.substring(j + 1);
 				}
 			}
 
 			if (newValue != 0) {
 				if (oldStringValue.charAt(0) == '.') {
 					newStringValue = "1" + newStringValue;
 				} else if ((oldStringValue.charAt(j + 1) == '.')
 				    && ((oldStringValue.charAt(j) == '+')
 				    || (oldStringValue.charAt(j) == '-')
 				    || (oldStringValue.charAt(j) == 'E'))) {
 					newStringValue = newStringValue.substring(0, 1) + "1"
 						+ newStringValue.substring(1);
 				} else {
 					newStringValue = newStringValue.substring(0, j + 1) + "10"
 						+ newStringValue.substring(j + 2);
 				}
 			}
 		} else if (newValue == ValueDigit.DECREASE_VALUE) {
 			boolean signTag = false;
 
 			for (int j = i;
 			    ((j >= 0) && (oldStringValue.charAt(j) != 'E')
 			    && (oldStringValue.charAt(j) != '+')
 			    && (oldStringValue.charAt(j) != '-')); j--) {
 				if ((oldStringValue.charAt(j) != '.')
 				    && (oldStringValue.charAt(j) != '0')) {
 					signTag = true;
 				}
 			}
 
 			if (signTag) {
 				for (int j = i;
 				    ((j >= 0) && (oldStringValue.charAt(j) != 'E')
 				    && (oldStringValue.charAt(j) != '+')
 				    && (oldStringValue.charAt(j) != '-') && (newValue != 0));
 				    j--) {
 					if (oldStringValue.charAt(j) == '.') {
 						
 					} else if (oldStringValue.charAt(j) != '0') {
 						newStringValue = newStringValue.substring(0, j)
 							+ String.valueOf(Integer.parseInt(
 							        newStringValue.substring(j, j + 1)) - 1)
 							+ newStringValue.substring(j + 1);
 						newValue = 0;
 					} else {
 						newStringValue = newStringValue.substring(0, j) + "9"
 							+ newStringValue.substring(j + 1);
 					}
 				}
 			} else {
 				int indexOfE = oldStringValue.indexOf('E');
 				char ones = '0';
 				if (getValue() == 0 && i <= indexOfE) {
 					ones = '1';
 				} else if (i > indexOfE) {
 					if (Double.parseDouble(oldStringValue.substring(indexOfE+1)) == 0.) {
 						ones = '1';
 					}
 				}
 				
 				if (i > indexOfE) {
 					if (oldStringValue.charAt(indexOfE + 1) == '+') {
 						newStringValue = newStringValue.substring(0,
 							    indexOfE + 1) + "-"
 							+ newStringValue.substring(indexOfE + 2, i) + ones
 							+ newStringValue.substring(i + 1);
 					} else if (oldStringValue.charAt(indexOfE + 1) == '-') {
 						newStringValue = newStringValue.substring(0,
 							    indexOfE + 1) + "+"
 							+ newStringValue.substring(indexOfE + 2, i) + ones
 							+ newStringValue.substring(i + 1);
 					} else {
 						newStringValue = newStringValue.substring(0,
 							    indexOfE + 1) + "-"
 							+ newStringValue.substring(indexOfE + 1, i) + ones
 							+ newStringValue.substring(i + 1);
 					}
 				} else {
 					if (oldStringValue.charAt(0) == '+') {
 						newStringValue = "-" + newStringValue.substring(1, i)
 							+ ones + newStringValue.substring(i + 1);
 					} else if (oldStringValue.charAt(0) == '-') {
 						newStringValue = "+" + newStringValue.substring(1, i)
 							+ ones + newStringValue.substring(i + 1);
 					} else {
 						newStringValue = "-" + newStringValue.substring(0, i)
 							+ ones + newStringValue.substring(i + 1);
 					}
 				}
 			}
 		}
 		setStringValue(newStringValue);
 	}
 
 	/**
 	 * Sets a new Digit selection.
 	 * @param i new digit selection.
 	 */
 	protected void setSelectedDigit(int i)
 	{
 		if (editable) {
 			if (i == selectedDigit) {
 				return;
 			}
 
 			if ((selectedDigit >= 0) && (selectedDigit < digits.size())) {
 				(digits.get(selectedDigit)).setSelected(false);
 			}
 
 			if ((i == INCREASE_SELECTION)
 			    || ((i >= 0) && (i < digits.size())
 			    && digits.get(i) instanceof StaticDigit)) {
 				if (i == INCREASE_SELECTION) {
 					i = selectedDigit;
 				}
 
 				while ((++i < digits.size())
 				    && digits.get(i) instanceof StaticDigit) {
 					
 				}
 
 				if (i == digits.size()) {
 					i = -1;
 
 					while (digits.get(++i) instanceof StaticDigit) {
 						
 					}
 				}
 			} else if (i == DECREASE_SELECTION) {
 				i = selectedDigit;
 
 				while ((--i >= 0) && digits.get(i) instanceof StaticDigit) {
 					
 				}
 
 				if (i < 0) {
 					i = digits.size();
 
 					while (digits.get(--i) instanceof StaticDigit) {
 						
 					}
 				}
 			}
 
 			if ((i >= 0) && (i < digits.size())) {
 				(digits.get(i)).setSelected(true);
 			}
 
 			selectedDigit = i;
 			getUpDownButton().setEnabled(selectedDigit >= 0 && selectedDigit < digits.size());
 		}
 	}
 
 	/**
 	 * Returns the currently selected digit.
 	 * @return int selection index
 	 */
 	protected int getSelectedDigit()
 	{
 		return selectedDigit;
 	}
 
 	/**
 	 * Fires a <code>SetEvent</code> to all currently
 	 * registered <code>SetListener</code>s of the <code>Wheelswitch</code>.
 	 */
 	protected void fireSetPerformed(double newValue)
 	{
 		Object[] listeners = listenerList.getListenerList();
 
 		for (int i = listeners.length - 2; i >= 0; i -= 2) {
 			if (listeners[i] == SetListener.class) {
 				((SetListener)listeners[i + 1]).setPerformed(new SetEvent(
 				        this, newValue));
 			}
 		}
 	}
 
 	/**
 	 * (Re)initializes existing value digits inside the wheelswitch.
 	 */
 	protected void initDigits()
 	{
 		String stringValue = formatter.getString();
 		char digitValue = 0;
 		boolean valueOutOfBounds = false;
 
 		if (getValue() > getGraphMax() || getValue() < getGraphMin()) {
 			valueOutOfBounds = true;
 		}
 
 		for (int i = 0; i < stringValue.length(); i++) {
 			digitValue = stringValue.charAt(i);
 			(digits.get(i)).setTilting(valueOutOfBounds);
 
 			if ((digitValue == '+') || (digitValue == '-')
 			    || (digitValue == 'E') || (digitValue == 'e')
 			    || (digitValue == '.')) {
 				//bugfix RT#11900 by jkamenik
 				(digits.get(i)).repaint();
 
 				//end bugfix
 			} else {
 				if (digits.get(i) instanceof ValueDigit) {
 					//bugfix RT#11900 by jkamenik
 					ValueDigit digit = ((ValueDigit)digits.get(i));
 					int newVal = Integer.parseInt(stringValue.substring(i, i
 						        + 1));
 
 					if (digit.getValue() != newVal) {
 						digit.setValue(newVal);
 					} else {
 						digit.repaint();
 					}
 
 					//end bugfix					    
 				} else {
 					Debug.out(
 					    "Wheelswitch#initDigits(): digits improperly synchronized");
 					setupValueDigits();
 					setupLayout();
 					validate();
 					repaint();
 
 					return;
 				}
 			}
 		}
 
 		//repaint();
 	}
 
 	/**
 	 * Repositions the components inside the wheelswitch.
 	 */
 	protected void setupLayout()
 	{
 		removeAll();
 
 		if(!digitsTakeUpAllSpace) {
 			for (int i = 0; i < hiddenDigits.size(); i++)
 				add(hiddenDigits.get(i));
 		}
 		
 		//  by mkadunc
 		//		add(Box.createHorizontalStrut(5));
 		for (int i = 0; i < digits.size(); i++) {
 			if ((digits.get(i)).getText().indexOf('E') != -1) {
 				add(Box.createHorizontalStrut(3));
 			}
 
 			add(digits.get(i));
 		}
 
 		if (unitDigits.size() != 0) {
 			add(Box.createHorizontalStrut(5));
 
 			for (int i = 0; i < unitDigits.size(); i++) {
 				add(unitDigits.get(i));
 			}
 		}
 
 		if (editable) {
 			add(Box.createHorizontalStrut(5));
 			add(getUpDownButton());
 		}
 
 		if (unitSeparate) {
 			add(Box.createHorizontalStrut(5));
 			add(getUnitLabel());
 		}
 
 		preferredSize = null;
 		minimumSize = null;
 
 		//requestFocusInWindow();
 	}
 
 	/**
 	 * Constructs unit digits from scratch.
 	 */
 	protected void setupUnitDigits()
 	{
 		unitDigits.clear();
 
 		String unit = formatter.getUnit();
 
 		if (unitSeparate) {
 			getUnitLabel().setText(unit);
 
 			return;
 		}
 
 		if (unit == null) {
 			return;
 		}
 
 		Digit digit = null;
 
 		for (int i = 0; i < unit.length(); i++) {
 			digit = new StaticDigit(unit.substring(i, i + 1));
 			digit.setEnhanced(enhanced);
 			digit.setEnabled(isEnabled());
 			digit.setAnimated(animated);
 			unitDigits.add(digit);
 		}
 	}
 
 	/**
 	 * Contructs value digits from scratch.
 	 */
 	protected void setupValueDigits()
 	{
 		digits.clear();
 		selectedDigit = -1;
 
 		String stringValue = formatter.getString();
 		char digitValue = 0;
 		Digit digit = null;
 		if (numberOfAllDigits >= stringValue.length()){
 		hiddenDigits.clear();
 			for (int i = 0; i < numberOfAllDigits - stringValue.length(); i++){
 				digit = new StaticDigit(" ");
 				digit.setVisible(false);
 				hiddenDigits.add(digit);
 			}
 		}
 		
 		boolean valueOutOfBounds = false;
 
 		if (getValue() > getGraphMax() || getValue() < getGraphMin()) {
 			valueOutOfBounds = true;
 		}
 
 		for (int i = 0; i < stringValue.length(); i++) {
 			digitValue = stringValue.charAt(i);
 
 			if ((digitValue >= '0') && (digitValue <= '9')) {
 				digit = new ValueDigit(Integer.parseInt(stringValue.substring(
 					            i, i + 1)));
 			} else {
 				digit = new StaticDigit(stringValue.substring(i, i + 1));
 			}
 
 			digit.addMouseListener(mouseHandler);
 			digit.setEnhanced(enhanced);
 			digit.setEnabled(isEnabled());
 			digit.setTilting(valueOutOfBounds);
 			digit.setAnimated(animated);
 			digits.add(digit);
 		}
 	}
 
 	/**
 	 * Called by setDigitValue(int,int) when the user modifies the digits.
 	 * Sets a new string value.
 	 */
 	private void setStringValue(String newStringValue)
 	{
 		int oldDigitSelection = getSelectedDigit();
 		int decimalSelection = parseDecimalPosition(oldDigitSelection);
 
 		if (debug) {
 			System.out.println("Wheelswitch::parseDecimalPosition = "
 			    + decimalSelection);
 		}
 
 		double oldValue = formatter.getValue();
 		String oldStringValue = formatter.getString();
 		
 		formatter.setString(newStringValue);
 
 		double newValue = formatter.getValue();
 		newStringValue = formatter.getString();
 
 		if (oldValue != newValue) {
 			firePropertyChange(VALUE, oldValue, newValue);
 			fireSetPerformed(newValue);
 		}
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		process(oldStringValue, newStringValue);
 
 		int newDigitSelection = parseDigitPosition(decimalSelection);
 
 		if (debug) {
 			System.out.println("Wheelswitch::parseDigitPosition = "
 			    + newDigitSelection);
 		}
 
 		if ((newDigitSelection < digits.size()) && (newDigitSelection >= 0)) {
 			setSelectedDigit(newDigitSelection);
 		} else {
 			setSelectedDigit(-1);
 		}
 
 		checkBounds();
 
 		//tiltHandler.tilt();
 	}
 
 	/**
 	 * Called by setStringValue(String). Computes the decimal position represented
 	 * by the digit position
 	 */
 	private int parseDecimalPosition(int digitPosition)
 	{
 		if (digitPosition == -1) {
 			return Integer.MAX_VALUE;
 		}
 
 		String digits = formatter.getString();
 		int decimalPosition = 0;
 		int expIndex = digits.indexOf('E');
 		int dotIndex = digits.indexOf('.');
 
 		if ((expIndex == -1) || (digitPosition < expIndex)) {
 			if (dotIndex != -1) {
 				decimalPosition += (dotIndex - digitPosition);
 			} else if (expIndex != -1) {
 				decimalPosition += (expIndex - digitPosition);
 			} else {
 				decimalPosition += (digits.length() - digitPosition);
 			}
 
 			if (decimalPosition > 0) {
 				decimalPosition--;
 			}
 
 			if (expIndex != -1) {
 				int exponent = (int)Double.parseDouble(digits.substring(expIndex
 					        + 1));
 				decimalPosition += exponent;
 			}
 		} else {
 			//multiples of hundreds are returned for exponent digits
 			decimalPosition = 100 * (digits.length() - digitPosition);
 		}
 
 		return decimalPosition;
 	}
 
 	/**
 	 * Called by setStringValue(String) Computes the digit position given the decimal
 	 * position
 	 */
 	private int parseDigitPosition(int decimalPosition)
 	{
 		if (decimalPosition == Integer.MAX_VALUE) {
 			return -1;
 		}
 
 		String digits = formatter.getString();
 		int digitPosition = 0;
 		int expIndex = digits.indexOf('E');
 		int dotIndex = digits.indexOf('.');
 
 		if (((decimalPosition % 100) == 0) && (decimalPosition != 0)) {
 			decimalPosition /= 100;
 
 			if ((expIndex == -1)
 			    || ((digits.length() - expIndex) < decimalPosition)) {
 				return Integer.MAX_VALUE;
 			}
 
 			digitPosition = digits.length() - decimalPosition;
 
 			if ((digits.charAt(digitPosition) == '+')
 			    || (digits.charAt(digitPosition) == '-')) {
 				return Integer.MAX_VALUE;
 			}
 
 			return digitPosition;
 		}
 
 		if (dotIndex != -1) {
 			digitPosition += (dotIndex - decimalPosition);
 		} else if (expIndex != -1) {
 			digitPosition += (expIndex - decimalPosition - 1);
 		} else {
 			digitPosition += (digits.length() - decimalPosition - 1);
 		}
 
 		if (expIndex != -1) {
 			int exponent = (int)Double.parseDouble(digits.substring(expIndex
 				        + 1));
 			digitPosition += exponent;
 		}
 
 		if ((expIndex != -1) && (digitPosition >= expIndex)) {
 			return Integer.MAX_VALUE;
 		} else if (digitPosition >= digits.length()) {
 			return Integer.MAX_VALUE;
 		}
 
 		if (digitPosition <= dotIndex) {
 			digitPosition--;
 		}
 
 		if ((digitPosition < 0)
 		    || ((digitPosition == 0)
 		    && ((digits.charAt(0) == '+') || (digits.charAt(0) == '-')))) {
 			return Integer.MAX_VALUE;
 		}
 
 		return digitPosition;
 	}
 
 	private synchronized void process(String oldStringValue,
 	    String newStringValue)
 	{
 		if ((oldStringValue.length() == newStringValue.length())
 		    && (oldStringValue.indexOf(".") == newStringValue.indexOf("."))
 		    && (oldStringValue.indexOf("E") == newStringValue.indexOf("E"))
 		    && (oldStringValue.indexOf("e") == newStringValue.indexOf("e"))
 		    && (oldStringValue.indexOf("+") == newStringValue.indexOf("+"))
 		    && (oldStringValue.indexOf("-") == newStringValue.indexOf("-"))
 		    && (oldStringValue.indexOf("+", oldStringValue.indexOf("E")) == newStringValue
 		    .indexOf("+", newStringValue.indexOf("E")))
 		    && (oldStringValue.indexOf("+", oldStringValue.indexOf("e")) == newStringValue
 		    .indexOf("+", newStringValue.indexOf("e")))
 		    && (oldStringValue.indexOf("-", oldStringValue.indexOf("e")) == newStringValue
 		    .indexOf("-", newStringValue.indexOf("e")))
 		    && (oldStringValue.indexOf("-", oldStringValue.indexOf("E")) == newStringValue
 		    .indexOf("-", newStringValue.indexOf("E")))) {
 			initDigits();
 		} else {
 			setupValueDigits();
 			setupLayout();
 			validate();
 			repaint();
 		}
 	}
 
 	/**
 	 * Determines wether currently the wheelswitch digits are animeted
 	 * (scrolling) or not.
 	 *
 	 * @return animated
 	 */
 	public boolean isAnimated()
 	{
 		return animated;
 	}
 
 	/**
 	 * Sets the animation property of wheelswith digits. When enabled, the
 	 * digits scroll when changing. <b>Caution! This feature may eat a lot of
 	 * CPU.</b>
 	 *
 	 * @param b
 	 */
 	public void setAnimated(boolean b)
 	{
 		if (this.animated == b) {
 			return;
 		}
 
 		firePropertyChange("animated", this.animated, b);
 		this.animated = b;
 
 		for (int i = 0; i < digits.size(); i++) {
 			(digits.get(i)).setAnimated(b);
 		}
 
 		for (int i = 0; i < unitDigits.size(); i++) {
 			(unitDigits.get(i)).setAnimated(b);
 		}
 	}
 
 	/**
 	 * Returns true if units are displayed in a separate label.
 	 *
 	 * @return true if units are separated
 	 */
 	public boolean isUnitSeparate()
 	{
 		return unitSeparate;
 	}
 
 	/**
 	 * Sets weather the unit should be displayed in a separate label on the
 	 * right of the component.
 	 *
 	 * @param unitSeparate The unitSeparate to set.
 	 */
 	public void setUnitSeparate(boolean unitSeparate)
 	{
 		this.unitSeparate = unitSeparate;
 	}
 
 	/**
 	 * Returns the formatter employed by the wheelswitch
 	 *
 	 * @return the formatter
 	 */
 	public AbstractWheelswitchFormatter getFormatter()
 	{
 		return formatter;
 	}
 
 	/**
 	 * Sets the formatter which handles the values set to the wheelswitch.
 	 *
 	 * @param formatter new formatter
 	 * @see com.cosylab.gui.components.wheelswtich.AbstractWheelswitchFormatter
 	 */
 	public void setFormatter(AbstractWheelswitchFormatter formatter)
 	{
 		if (formatter==null) {
 			throw new NullPointerException("formatter");
 		}
 		
 		String unit = this.formatter.getUnit();
 		String format = this.formatter.getFormat();
 		String string = this.formatter.getString();
 		double value = this.formatter.getValue();
 		double max = this.formatter.getMaximum();
 		double min = this.formatter.getMinimum();
 		int maxDigits = this.formatter.getMaximumDigits();
 
 		this.formatter = formatter;
 
 		this.formatter.setFormat(format);
 		this.formatter.setUnit(unit);
 		this.formatter.setString(string);
 		this.formatter.setValue(value);
 		this.formatter.setMaximum(max);
 		this.formatter.setMinimum(min);
 		this.formatter.setMaximumDigits(maxDigits);
 
 		process(string, formatter.getString());
 	}
 
     /**
      * Sets the maximum font size for the units label.
      * 
      * @param max new maximum size in pixels
      */
     public void setUnitsMaximumFontSize(int max) {
         getUnitLabel().setMaximumFontSize(max);
     }
 
     /**
      * Sets the minimum font size for the units label.
      * 
      * @param min new minimum font size in pixels
      */
     public void setUnitsMinimumFontSize(int min) {
     	getUnitLabel().setMinimumFontSize(min);
     }
     
     /**
      * Returns the maximum font size of the units label.
      * 
      * @return the font size in pixels
      */
     public int getUnitsMaximumFontSize() {
         return getUnitLabel().getMaximumFontSize();
     }
 
     /**
      * Returns the minimum font size of the units label.
      * 
      * @return the font size in pixels
      */
     public int getUnitsMinimumFontSize() {
         return getUnitLabel().getMinimumFontSize();
     }
     
     /*
      * (non-Javadoc)
      * @see javax.swing.JComponent#setBackground(java.awt.Color)
      */
     @Override
     public void setBackground(Color bg) {
     	super.setBackground(bg);
     	getUpDownButton().setBackground(bg);
     	getUnitLabel().setBackground(bg);
     }
     
     /*
      * (non-Javadoc)
      * @see javax.swing.JComponent#setForeground(java.awt.Color)
      */
     @Override
     public void setForeground(Color fg) {
     	super.setForeground(fg);
     	getUpDownButton().setForeground(fg);
     	getUnitLabel().setForeground(fg);
     }
     
     /**
      * Set <code>true</code> if digits should take up all space, set 
      * <code>false</code> if place for not visible digits should be reserved
      * (there is no resizing of digits when 9 changes to 10 etc.).
      * </p>
      * Set the number of reserved place with {@link #setNumberOfAllDigits(int)}.
      * </p>
      * @param bool boolean value
      */
     public void setDigitsTakeUpAllSpace(boolean bool) {
     	if (digitsTakeUpAllSpace == bool)
     		return;
     	
     	firePropertyChange("digitsTakeUpAllSpace", digitsTakeUpAllSpace, bool);
     	digitsTakeUpAllSpace = bool;
     	
     	setupValueDigits();
 		setupUnitDigits();
 		setupLayout();
 		validate();
 		repaint();
     }
     
     /**
      * @return <code>true</code> if digits take up all space,
      *  otherwise <code>false</code>
      */
     public boolean getDigitsTakeUpAllSpace() {
     	return digitsTakeUpAllSpace;
     }
     
     /**
      * If {@link #setDigitsTakeUpAllSpace(boolean)} is set to <code>false</code>
      * the place for <code>numberOfAllDigits</code> is reserved. Not needed 
      * additional digits are not shown.
      * 
      * @param numberOfAllDigits number of all digits
      */
     public void setNumberOfAllDigits(int numberOfAllDigits) {
     	if(this.numberOfAllDigits == numberOfAllDigits)
     		return;
     	
     	firePropertyChange("numberOfAllDigits", this.numberOfAllDigits, numberOfAllDigits);
     	this.numberOfAllDigits = numberOfAllDigits;
     	
     	setupValueDigits();
 		setupUnitDigits();
 		setupLayout();
 		validate();
 		repaint();
     }
     
     /**
      * @return The number of reserved places for digits.
      */
     public int getNumberOfAllDigits() {
     	return(numberOfAllDigits);
     }
 
 	public static void main(String[] args)
 	{
 		Wheelswitch ws = new Wheelswitch(WheelswitchFormatter.transformFormat(
 			        "%3.2E2"), 0, "deg:min:sec");
 //		ws.setFormatter(new RadialWheelswitchFormatter());
 		ws.setAnimated(true);
 		ws.setDigitsTakeUpAllSpace(false);
 		//ws.setValue(1);
 		JFrame f = new JFrame();
 		f.getContentPane().setLayout(new BorderLayout());
 		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 		f.getContentPane().add(ws, BorderLayout.CENTER);
 		f.getContentPane().add(new JButton("focus"), BorderLayout.SOUTH);
 		f.setSize(300, 100);
 		f.setVisible(true);
 	}
 
 }
 
 /* __oOo__ */