/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.Font;
  import 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.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.util.ArrayList;
  
  import javax.swing.AbstractAction;
  import javax.swing.Icon;
  import javax.swing.JPanel;
  import javax.swing.JSlider;
  import javax.swing.Timer;
  import javax.swing.UIDefaults;
  import javax.swing.UIManager;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.events.SetEvent;
  import com.cosylab.events.SetListener;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.range2.IntegerValuePolicy;
  import com.cosylab.gui.components.range2.LinearRange;
  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.TickParameters;
  import com.cosylab.gui.components.slider.CosySliderUI;
  import com.cosylab.gui.components.slider.InfoBar;
  import com.cosylab.gui.components.slider.NavigationBar;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyTransferHandler;
  import com.cosylab.gui.components.util.CosyUIElements;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.RunnerHelper;
  import com.cosylab.util.PrintfFormat;
  
  /**
   * Slider is a GUI component for displaying double value. Slider defines limits within
   * which the value may be set and fire update events when this value is changed. For
   * precise control, textual entry and button controls are also available.
   * <p>
   * When displaying values slider can show two different values. The front thumb displays
   * the value that was set by the user. According to the set mode currently set on the
   * Slider ({@link #setSetMode(SliderSetMode)}) slider then notifies listeners of the value
   * change. The second value is displayed by a grey shadow. This value can be controlled by
   * the {@link #setReadback(double)} method and can only be changed manually (through this
   * method call).
   * 
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj </a>
   * @version $id$
   */
  public class Slider extends JPanel implements TickParameters, PopupManageable, StateOriginator {
  
  	/**
  	 * Button identifiers for any of the buttons used in the Slider.
  	 * 
  	 * @see Slider#setButtonTooltip(com.cosylab.gui.components.Slider.Button, String)
  	 * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
  	 * @version $Id: Slider.java,v 1.84 2009-01-12 12:46:02 jbobnar Exp $
  	 */
  	public enum Button {
  		FAST_INCREMENT, FAST_DECREMENT, BIT_INCREMENT, BIT_DECREMENT, SLOW_INCREMENT, SLOW_DECREMENT,
  	}
  
  	private static final long serialVersionUID = 1L;
  
  	private boolean popupEnabled;
 
 	/**
 	 * Set only when demanded
 	 * 
 	 * @deprecated use {@link SliderSetMode#SET_MANUAL} instead.
 	 */
 	@Deprecated
 	public static final int SET_MANUAL = 0;
 
 	/**
 	 * Set when dragging stops
 	 * 
 	 * @deprecated use {@link SliderSetMode#SET_ON_RELEASE} instead.
 	 */
 	@Deprecated
 	public static final int SET_ON_RELEASE = 1;
 
 	/**
 	 * Set when value changes
 	 * 
 	 * @deprecated use {@link SliderSetMode#SET_ON_CHANGE} instead.
 	 */
 	@Deprecated
 	public static final int SET_ON_CHANGE = 2;
 
 	private AbstractCustomizerPanel customizer;
 	private PopupManager popupManager;
 
 	private final ArrayList<SetListener> listeners = new ArrayList<SetListener>();
 	
 	private JSlider slider;
 	private CosySliderUI sliderUI;
 	private InfoBar infoBar;
 	private NavigationBar navigationBar;
 
 	private RangedValueController rangedValue;
 
 	// suspended count
 	private int suspended = 0;
 	private boolean showIntegerOnly = false;
 	private boolean supressChanges = false;
 	private boolean supressSetEvent = false;
 	private boolean supressPropChEvent = false;
 	private boolean externalSet = false;
 
 	private static final double DEFAULT_BIT_STEP = 1;
 	private static final double DEFAULT_SMALL_STEP = 10;
 	private static final double DEFAULT_LARGE_STEP = 25;
 	
 	// BitStep value , to tell slider how big the step should be
 	private double bitStep = DEFAULT_BIT_STEP;
 	// If isBitSteepRelative=false then we change absulut value else relative
 	private boolean isBitStepRelative = true;
 	// SmallStep value , to tell slider how big the step should be
 	private double smallStep = DEFAULT_SMALL_STEP;
 	// If isSmallSteepRelative=false then we change absulute value else relative
 	private boolean isSmallStepRelative = true;
 	// LargeStep value , to tell slider how big the step should be
 	private double largeStep = DEFAULT_LARGE_STEP;
 	// If isLargeSteepRelative=false then we change absulut value else relative
 	private boolean isLargeStepRelative = true;
 
 	
 	// For autosynchronization see RT #22324
 	private Timer autoSyncTimer;
 	/*
 	 * Flag indicating whether the slider is automatically synchronized each time the
 	 * readback changes. Synchronization occurs after the autoSynchronizeDelay miliseconds
 	 * pass since the last user intervention.
 	 */
 	private boolean autoSynchronize = false;
 	/*
 	 * The time in milliseconds that have to pass since last user intervention for the
 	 * automatical synchronization to occur for the first time.
 	 */
 	private long autoSynchronizeDelay = 2000;
 	private boolean allowAutoSync = true;
 	private double storedValue = Double.NaN;
 	private boolean continuousControlVisible = false;
 	private boolean continuousModeEnabled = false;
 	
 	private PrintfFormat formatter;
 	private String title = " ";
 	private boolean settable = true;
 	private SliderSetMode mode = SliderSetMode.SET_ON_CHANGE;
 	private boolean snapToTicks = false;
 
 	private ManualTickCalculator manualTickProvider = new ManualTickCalculator();
 
 	private class ValueListener implements RangedValueListener {
 		/**
 		 * @see com.cosylab.gui.components.range.RangedValueListener#valueChanged(RangedValueEvent)
 		 */
 		public void valueChanged(RangedValueEvent event) {
 			if (event.isMinOrMaxChanged()) {
 
 				getSlider().setValue((int)getRangedValue().getRelativeValue());
 
 				getSliderUI().setTrailerPosition(getSliderUI().getTrailerPosition());
 				getNavigationBar().setMinimum(getRangedValue().getMinimum());
 				getNavigationBar().setMaximum(getRangedValue().getMaximum());
 				repaint();
 
 			}
 		}
 	}
 
 	/**
 	 * Resets sliders steps to default values
 	 */
 	public void resetSteps() {
 		setBitStep(DEFAULT_BIT_STEP);
 		setBitStepRelative(true);
 		setSmallStep(DEFAULT_SMALL_STEP);
 		setSmallStepRelative(true);
 		setLargeStep(DEFAULT_LARGE_STEP);
 		setLargeStepRelative(true);
 	}
 	
 	private PrintfFormat getFormatter() {
 		if (formatter == null) {
 			formatter = new PrintfFormat("%f");
 		}
 		return formatter;
 	}
 
 	/**
 	 * Listens for changes to draggable slider button.
 	 * 
 	 * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj </a>
 	 * @version $id$
 	 */
 	private class SliderChange implements ChangeListener {
 		/**
 		 * Notifies of value change.
 		 * 
 		 * @param event ChangeEvent
 		 * @see javax.swing.event.ChangeListener#stateChanged(ChangeEvent)
 		 */
 		public void stateChanged(ChangeEvent event) {
 			if (mode == SliderSetMode.SET_ON_CHANGE || mode == SliderSetMode.SET_MANUAL) {
 				performInternalSliderSet();
 			}
 			if (!externalSet || mode == SliderSetMode.SET_ON_RELEASE) {
 				getNavigationBar().setValue(getRangedValue().toAbsolute(getSlider().getValue()));
 			}
 		}
 	}
 
 	/**
 	 * Creates a new Slider object.
 	 */
 	public Slider() {
 		super();
 		initialize();
 	}
 
 	/**
 	 * Adds set listener. SetListener receives events when the thumb was dragged by the
 	 * mouse.
 	 * 
 	 * @param listener SetListener
 	 */
 	public void addSetListener(SetListener listener) {
 		synchronized (listeners) {
 			listeners.add(listener);
 		}
 	}
 
 	/**
 	 * Removes set listener.
 	 * 
 	 * @param listener SetListener
 	 */
 	public void removeSetListener(SetListener listener) {
 		synchronized (listeners) {
 			listeners.remove(listener);
 		}
 	}
 
 	/**
 	 * Fires event that value has changed.
 	 * 
 	 * @param newValue double
 	 */
 	protected void fireSetPerformed(double newValue) {
 		final SetEvent e = new SetEvent(this,newValue);
 
 		synchronized (listeners) {
 			final int n = listeners.size();
 
 			for (int i = 0; i < n; i++) {
 				listeners.get(i).setPerformed(e);
 			}
 		}
 	}
 
 	private void initialize() {
 		setLayout(new GridBagLayout());
 		setBorder(CosyUIElements.getPlainBorder(true));
 		setBackground(ColorHelper.getCosyControl());
 
 		add(getInfoBar(),new GridBagConstraints(0,0,1,1,1,0,GridBagConstraints.CENTER,GridBagConstraints.HORIZONTAL,new Insets(1,2,2,2),0,0));
 		add(getNavigationBar(),new GridBagConstraints(0,1,1,1,1,0,GridBagConstraints.CENTER,GridBagConstraints.HORIZONTAL,new Insets(1,2,2,2),0,0));
 
 		GridBagConstraints gc = new GridBagConstraints();
 
 		gc.gridx = 0;
 		gc.gridy = 2;
 		gc.weightx = 1.0;
 		gc.weighty = 0.0;
 		gc.fill = GridBagConstraints.HORIZONTAL;
 		gc.insets = new Insets(0,2,0,2);
 
 		getSliderUI().setTolerance(0.0000001);
 		add(getSlider(),gc);
 
 		setValue(0);
 		setForeground(Color.BLACK);
 		setStorageButtonsVisible(false);
 		setContinuousControlVisible(false);
 		setPopupEnabled(true);
 	}
 
 	protected InfoBar getInfoBar() {
 		if (infoBar == null) {
 			infoBar = new InfoBar(this);
 		}
 
 		return infoBar;
 	}
 
 	protected NavigationBar getNavigationBar() {
 		if (navigationBar == null) {
 			navigationBar = new NavigationBar(this);
 			navigationBar.addSetListener(new SetListener() {
 
 				public void setPerformed(SetEvent e) {
 					performInternalSet(e.getDoubleValue());
 				}
 
 			});
 		}
 
 		return navigationBar;
 	}
 
 	protected JSlider getSlider() {
 		if (slider == null) {
 			slider = new JSlider();
 			slider.setBackground(ColorHelper.getCosyControl());
 			slider.setPaintLabels(true);
 			slider.setPaintTicks(true);
 			slider.setMinorTickSpacing(10000);
 			slider.setMajorTickSpacing(10000);
 
 			slider.setMinimum(0);
 			slider.setMaximum(10000);
 
 			// *** BUGFIX ***
 			// This is bugfix for netbeans 3.6RC1 L&F problem
 			// It appears there is a problem with how the NB L&F is implemented.
 			// Done to resolve RT#5535
 			// Setting these global variables may affect other sliders,
 			// depending
 			// on Metal or all L&F settings
 			// ***
 			UIManager.put("Slider.trackWidth",new Integer(7));
 			UIManager.put("Slider.majorTickLength",new Integer(6));
 			UIManager.put("Slider.horizontalThumbIcon",new UIDefaults.ProxyLazyValue("javax.swing.plaf.metal.MetalIconFactory",
 					"getHorizontalSliderThumbIcon"));
 			UIManager.put("Slider.verticalThumbIcon",new UIDefaults.ProxyLazyValue("javax.swing.plaf.metal.MetalIconFactory",
 					"getVerticalSliderThumbIcon"));
 
 			// *** END BUGFIX ***
 			slider.setUI(getSliderUI());
 			slider.addChangeListener(new SliderChange());
 			slider.addMouseListener(new MouseAdapter() {
 
 				@Override
 				public void mousePressed(MouseEvent e) {
 					allowAutoSync = false;
 				}
 
 				@Override
 				public void mouseReleased(MouseEvent e) {
 					if (mode == SliderSetMode.SET_ON_RELEASE) {
 						performInternalSliderSet();
 					} else if (showIntegerOnly) {
 						getSlider().setValue((int)(getRangedValue().getRelativeValue()));
 					}
 					allowAutoSync = true;
 
 				}
 			});
 			slider.setPreferredSize(new Dimension(150,50));
 		}
 		return slider;
 	}
 
 	private int old = Integer.MIN_VALUE;
 
 	private void performInternalSliderSet() {
 		synchronized (this) {
 			if (!supressChanges) {
 				int newV = getSlider().getValue();
 				if (old != newV) {
 					performInternalSetRelative(newV);
 				}
 				old = newV;
 			}
 		}
 	}
 
 	private void performInternalSet(double value) {
 
 		value = getRangedValue().validate(value);
 
 		if (value == getValue()) {
 			return;
 		}
 		
 		getNavigationBar().setValue(value);
 
 		if (mode == SliderSetMode.SET_MANUAL) {
 			synchronized (this) {
 				if (!supressChanges) {
 					supressChanges = true;
 
 					getRangedValue().setValue(value);
 					// distribute change
 					getSlider().setValue((int)getRangedValue().getRelativeValue());
 					getNavigationBar().setValue(getValue());
 
 					supressChanges = false;
 				}
 			}
 			return;
 		}
 
 		synchronized (this) {
 			if (!supressChanges) {
 				supressChanges = true;
 
 				getAutoSyncTimer().stop();
 
 				double old = getValue();
 				getRangedValue().setValue(value);
 
 				// distribute change
 				getSlider().setValue((int)getRangedValue().getRelativeValue());
 				getNavigationBar().setValue(getValue());
 				
 				if (!isEditable()) {
 					setReadback(getValue());
 				}
 
 				if (!supressSetEvent && !isSuspended()) {
 					fireSetPerformed(getValue());
 				}
 				if (!supressPropChEvent && !isSuspended()) {
 					firePropertyChange("value",old,getValue());
 				}
 
 				if (autoSynchronize) {
 					getAutoSyncTimer().restart();
 				}
 
 				supressChanges = false;
 			}
 		}
 
 	}
 
 	private void performInternalSetRelative(double rVal) {
 		performInternalSet(getRangedValue().toAbsolute(rVal));
 	}
 	
 	private void performInternalFractionSet(double fraction) {
 		performInternalSetRelative(getRangedValue().getRelativeValue() + fraction * getRangedValue().getScalingFactor());
 
 	}
 
 	/**
 	 * Create this slider UI.
 	 * 
 	 * @return the ui
 	 */
 	protected CosySliderUI getSliderUI() {
 		if (sliderUI == null) {
 			sliderUI = new CosySliderUI(getRangedValue());
 		}
 
 		return sliderUI;
 	}
 	
 	/**
 	 * Sets new minimum value.
 	 * 
 	 * @param minimum new minimum value.
 	 */
 	public void setMinimum(double minimum) {
 		double oldValue = getMinimum();
 		// double trailerValue = getSliderUI().getTrailerPosition();
 		getRangedValue().setMinimum(minimum);
 		/*
 		 * If minimum has changed, navigationBar's minimum and slider's scale and position
 		 * has to be modified.
 		 */
 		getNavigationBar().setMinimum(minimum);
 		modifySliderPosition();
 		firePropertyChange("minimum",oldValue,minimum);
 	}
 
 	/**
 	 * Sets new maximum value.
 	 * 
 	 * @param maximum new maximum value.
 	 */
 	public void setMaximum(double maximum) {
 		double oldValue = getMaximum();
 		// double trailerValue = getSliderUI().getTrailerPosition();
 		getRangedValue().setMaximum(maximum);
 		/*
 		 * If maximum has changed, navigationBar's maximum and slider's scale and position
 		 * has to be modified.
 		 */
 		getNavigationBar().setMaximum(maximum);
 		modifySliderPosition();
 		firePropertyChange("maximum",oldValue,maximum);
 	}
 
 	/**
 	 * Sets the new value that this slider will display. This method will set the front
 	 * thumb value.
 	 * 
 	 * @param value new value.
 	 */
 	public void setValue(double value) {
 		getAutoSyncTimer().stop();
 
 		double oldValue = getValue();
 
 		synchronized (this) {
 			supressChanges = true;
 			getRangedValue().setValue(value);
 			// distribute change
 			
 			externalSet = true;
 			getSlider().setValue((int)getRangedValue().getRelativeValue());
 			getNavigationBar().setValue(getValue());
 			
 			if (!isEditable()) {
 				setReadback(getValue());
 			}
 
 			supressChanges = false;
 		}
 
 		if (autoSynchronize) {
 			getAutoSyncTimer().restart();
 		}
 
 		firePropertyChange("value",oldValue,value);
 	}
 
 	private Timer getAutoSyncTimer() {
 		if (autoSyncTimer == null) {
 			autoSyncTimer = new Timer((int)autoSynchronizeDelay,new ActionListener() {
 				public void actionPerformed(ActionEvent e) {
 					if (allowAutoSync) synchronize();
 					autoSyncTimer.stop();
 				}
 			});
 		}
 		return autoSyncTimer;
 	}
 
 	/**
 	 * Returns currently set minimum value.
 	 * 
 	 * @return double minimum value.
 	 */
 	public double getMinimum() {
 		return getRangedValue().getMinimum();
 	}
 
 	/**
 	 * Returns currently set maxium value.
 	 * 
 	 * @return double maximum value.
 	 */
 	public double getMaximum() {
 		return getRangedValue().getMaximum();
 	}
 
 	/**
 	 * Returns current value the slider is displaying.
 	 * 
 	 * @return double Current value.
 	 */
 	public double getValue() {
 		/*
 		 * Fix for out of bounds behaviour of this component (RT #26250). Replaced: return
 		 * getRangedValue().getValue();
 		 */
 		return getRangedValue().getRawValue();
 	}
 
 	/**
 	 * Sets string representing units displayed next to value entry field.
 	 * 
 	 * @param units new value for units, may be null.
 	 */
 	public void setUnits(String units) {
 		String oldValue = getUnits();
 		getNavigationBar().setUnits(units);
 		firePropertyChange("units",oldValue,units);
 	}
 
 	/**
 	 * Returns string representing units that are displayed next to value entry field.
 	 * 
 	 * @return String units string.
 	 */
 	public String getUnits() {
 		return getNavigationBar().getUnits();
 	}
 
 	/**
 	 * Sets whether units are displayed next to value entry field.
 	 * 
 	 * @param b wehter units are displayed.
 	 */
 	public void setUnitsVisible(boolean b) {
 		if (isUnitsVisible() == b) return;
 		getNavigationBar().setUnitsVisible(b);
 		firePropertyChange("unitsVisible",!b,b);
 	}
 
 	/**
 	 * Returns true if units are displayed next to value entry field.
 	 * 
 	 * @return boolean unitsVisible.
 	 */
 	public boolean isUnitsVisible() {
 		return getNavigationBar().isUnitsVisible();
 	}
 	
 	//used only in the method below
 	private double lastReadbackValue = Double.NaN;
 
 	/**
 	 * Sets the readback indicator position. This determines the position of trailer
 	 * shadow that is displayed to indicate last readback. <br>
 	 * This method has no effect if slider is not settable.
 	 * 
 	 * @param value double new readback position.
 	 */
 	public void setReadback(double value) {
 		double oldValue = getReadback();
 		getSliderUI().setTrailerPosition(value);
 		if (value < getMinimum() || value > getMaximum()) {
 			getNavigationBar().setValue(value);
 		}
 		if (autoSynchronize) {
 			if (lastReadbackValue != value) {
 				getAutoSyncTimer().restart();
 			} else {
 				if (!getAutoSyncTimer().isRunning()) {
 					getAutoSyncTimer().start();
 				}
 			}
 
 		}
 
 		lastReadbackValue = value;
 		firePropertyChange("readBack",oldValue,value);
 		if (!isEditable() || !isSyncButtonVisible()) {
 			synchronize();
 		}
 	}
 	
 	/**
 	 * Returns ranged value representing this slider's value.
 	 * 
 	 * @return RangedValue.
 	 */
 	private RangedValueController getRangedValue() {
 		if (rangedValue == null) {
 			rangedValue = new RangedValueController();
 			rangedValue.setRange(new LinearRange());
 			rangedValue.setScalingFactor(10000);
 			rangedValue.addRangedValueListener(new ValueListener());
 		}
 
 		return rangedValue;
 	}
 
 	/**
 	 * Returns current readback position. This is the position of the trailer shadow thad
 	 * indicates last readback. <br>
 	 * If slider is not settable the method will return the value of the front thumb.
 	 * 
 	 * @return double the readback value
 	 */
 	public double getReadback() {
 		return getSliderUI().getTrailerPosition();
 	}
 
 	/**
 	 * Sets format for navigator and ticks.
 	 * 
 	 * @param s new C-Style format.
 	 * @deprecated use {@link #setTicksFormat(String)} and {@link #setFieldFormat(String)}
 	 */
 	@Deprecated
 	public void setFormat(String s) {
 		String oldValue = getFormat();
 		setFieldFormat(s);
 		setTicksFormat(s);
 		firePropertyChange("format",oldValue,s);
 	}
 	
 	/**
 	 * Returns the format used for number labels on the slider. This method
 	 * in fact returns the format of the number field.
 	 * 
 	 * @return the C-style format
 	 * @deprecated use {@link #getTicksFormat()} and {@link #getFieldFormat()} 
 	 */
 	@Deprecated
 	public String getFormat() {
 		return getFieldFormat();
 	}
 	
 	
 	/**
 	 * Sets format for editable field.
 	 * 
 	 * @param s new C-Style format.
 	 */
 	public void setFieldFormat(String s) {
 		String oldValue = getFieldFormat();
 		getNavigationBar().setFormat(s);
 		if (Double.isNaN(storedValue)) {
 			getInfoBar().setStoredValue(null);
 		} else {
 			getInfoBar().setStoredValue(getNavigationBar().format(storedValue));
 		}
 		firePropertyChange("fieldFormat",oldValue,s);
 	}
 	
 	/**
 	 * Returns format of the editable field.
 	 * 
 	 * @return C-Style format.
 	 */
 	public String getFieldFormat() {
 		return getNavigationBar().getFormat();
 	}
 	
 	private RangedValuePolicy integerPolicy = new IntegerValuePolicy();
 	
 	/**
 	 * Sets the string format for the ticks of this slider. This format
 	 * will affect only the strings in the slider scale but not the ticks
 	 * in the naviagtion bar.
 	 * 
 	 * @param ticksFormat the ticks format
 	 */
 	public void setTicksFormat(String ticksFormat) {
 		String oldValue = getTicksFormat();
 		if (ticksFormat.contains("%d")) {
 			showIntegerOnly = true;
 			getRangedValue().addPolicy(integerPolicy);
 			// round to tick
 			setValue(getValue());
 		} else {
 			getRangedValue().removePolicy(integerPolicy);
 			showIntegerOnly = false;
 		}
 		getSliderUI().setFormat(ticksFormat);
 		formatter = new PrintfFormat(ticksFormat);
 		firePropertyChange("ticksFormat",oldValue,ticksFormat);
 		// repaint ticks
 		repaint();
 	}
 		
 	/**
 	 * Returns the formatter used for the slider ticks on the scale.
 	 * 
 	 * @return the ticks format
 	 */
 	public String getTicksFormat() {
 		return getSliderUI().getFormat();
 	}
 
 	/**
 	 * Returns the title of the Slider.
 	 * 
 	 * @return title.
 	 */
 	public String getTitle() {
 		return getInfoBar().getTitle();
 	}
 
 	/**
 	 * Sets the title of the slider.
 	 * 
 	 * @param title new title
 	 */
 	public void setTitle(String title) {
 		String oldValue = getTitle();
 		this.title = title;
 		getInfoBar().setTitle(title);
 		firePropertyChange("title",oldValue,title);
 	}
 
 	/**
 	 * Sets the visibility of the title.
 	 * 
 	 * @param titleVisible true if title should be visible
 	 */
 	public void setTitleVisible(boolean titleVisible) {
 		if (getTitleVisible() == titleVisible) return;
 		if (!titleVisible) {
 			title = getInfoBar().getTitle();
 			getInfoBar().setTitle(" ");
 		} else {
 			getInfoBar().setTitle(this.title);
 		}
 		firePropertyChange("titleVisible",!titleVisible,titleVisible);
 	}
 
 	/**
 	 * Returns true if title is visible.
 	 * 
 	 * @return true if title is visible
 	 */
 	public boolean getTitleVisible() {
 		return !getInfoBar().getTitle().equals("");
 	}
 
 	/**
 	 * Performs a small value increment.
 	 * 
 	 * @see #setSmallStep(double)
 	 */
 	public void incrementSmall() {
 		if (isSmallStepRelative()) {
 			performInternalFractionSet(getSmallStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() + getSmallStep()));
 		}
 	}
 
 	/**
 	 * Peforms a large value increment.
 	 * 
 	 * @see #setLargeStep(double)
 	 */
 	public void incrementLarge() {
 		if (isLargeStepRelative() == true) {
 			performInternalFractionSet(getLargeStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() + getLargeStep()));
 		}
 	}
 
 	/**
 	 * Increments value for a single bit.
 	 * 
 	 * @see #setBitStep(double)
 	 */
 	public void incrementBit() {
 		if (isBitStepRelative()) {
 			performInternalFractionSet(getBitStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() + getBitStep()));
 		}
 	}
 
 	/**
 	 * Decrements value for a single bit.
 	 * 
 	 * @see #setBitStep(double)
 	 */
 	public void decrementBit() {
 		if (isBitStepRelative()) {
 			performInternalFractionSet(-getBitStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() - getBitStep()));
 		}
 	}
 
 	/**
 	 * Decrements value for the small step.
 	 * 
 	 * @see #setSmallStep(double)
 	 */
 	public void decrementSmall() {
 		if (isSmallStepRelative()) {
 			performInternalFractionSet(-getSmallStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() - getSmallStep()));
 		}
 	}
 
 	/**
 	 * Decrements value for the large step.
 	 * 
 	 * @see #setLargeStep(double)
 	 */
 	public void decrementLarge() {
 		if (isLargeStepRelative()) {
 			performInternalFractionSet(-getLargeStep() / 100);
 		} else {
 			performInternalSet(getRangedValue().validate(getValue() - getLargeStep()));
 		}
 	}
 
 	/**
 	 * Sets the value of a bit step.
 	 * 
 	 * @param value new bit step
 	 */
 	public void setBitStep(double value) {
 		double oldValue = getBitStep();
 		bitStep = value;
 		firePropertyChange("bitStep",oldValue,value);
 	}
 
 	/**
 	 * Returns the value of bit step.
 	 * 
 	 * @return bitStep the bit step
 	 */
 	public double getBitStep() {
 		return bitStep;
 	}
 
 	/**
 	 * Returns the value of the small step.
 	 * 
 	 * @return current small step.
 	 */
 	public double getSmallStep() {
 		return smallStep;
 	}
 
 	/**
 	 * Sets the small step.
 	 * 
 	 * @param value new small step
 	 */
 	public void setSmallStep(double value) {
 		double oldValue = getSmallStep();
 		smallStep = value;
 		firePropertyChange("smallStep",oldValue,value);
 	}
 
 	/**
 	 * Sets the value of large step
 	 * 
 	 * @param value new large step
 	 */
 	public void setLargeStep(double value) {
 		double oldValue = getLargeStep();
 		largeStep = value;
 		firePropertyChange("largeStep",oldValue,value);
 	}
 
 	/**
 	 * Returns the value of largeStep.
 	 * 
 	 * @return current large step
 	 */
 	public double getLargeStep() {
 		return largeStep;
 	}
 
 	/**
 	 * Returns true if bitStep is relative, else false.
 	 * 
 	 * @return
 	 */
 	public boolean isBitStepRelative() {
 		return isBitStepRelative;
 	}
 
 	/**
 	 * Sets bitStep to be relative if true (example: bitStep=20 means that bitStep will
 	 * change for 20% of sliders current range(min,max)).
 	 * 
 	 * @param value true is realtive
 	 */
 	public void setBitStepRelative(boolean value) {
 		if (isBitStepRelative() == value) return;
 		isBitStepRelative = value;
 		firePropertyChange("bitStepRelative",!value,value);
 	}
 
 	/**
 	 * Returns true if smallStep is relative, else false.
 	 * 
 	 * @return
 	 */
 	public boolean isSmallStepRelative() {
 		return isSmallStepRelative;
 	}
 
 	/**
 	 * Sets smallStep to be relative if true (example: smallStep=20 means that smallStep
 	 * will change for 20% of sliders current range(min,max)).
 	 * 
 	 * @param value true if relative
 	 */
 	public void setSmallStepRelative(boolean value) {
 		if (isSmallStepRelative() == value) return;
 		isSmallStepRelative = value;
 		firePropertyChange("smallStepRelative",!value,value);
 	}
 
 	/**
 	 * Returns true if largeStep is relative, else false.
 	 * 
 	 * @return
 	 */
 	public boolean isLargeStepRelative() {
 		return isLargeStepRelative;
 	}
 
 	/**
 	 * Sets largeStep to be relative if true (example: largeStep=20 means that largeStep
 	 * will change for 20% of sliders current range(min,max)).
 	 * 
 	 * @param value true if relative
 	 */
 	public void setLargeStepRelative(boolean value) {
 		if (isLargeStepRelative() == value) return;
 		isLargeStepRelative = value;
 		firePropertyChange("largeStepRelative",!value,value);
 	}
 
 	/**
 	 * Return set mode.
 	 * 
 	 * @return int
 	 * @deprecated use {@link Slider#getSetMode()}
 	 */
 	@Deprecated
 	public int getMode() {
 		return mode.ordinal();
 	}
 
 	/**
 	 * Sets the set mode.
 	 * 
 	 * @param newMode int
 	 * @deprecated use
 	 *             {@link Slider#setSetMode(com.cosylab.gui.components.Slider.SetMode)}
 	 */
 	@Deprecated
 	public void setMode(int newMode) {
 		setSetMode(SliderSetMode.valueOf(newMode));
 	}
 
 	/**
 	 * Sets the slider set mode.
 	 * 
 	 * @param mode
 	 * @see SliderSetMode
 	 */
 	public void setSetMode(SliderSetMode mode) {
 		SliderSetMode oldValue = getSetMode();
 		this.mode = mode;
 		getInfoBar().setSetButtonVisible(mode == SliderSetMode.SET_MANUAL);
 		firePropertyChange("setMode",oldValue,this.mode);
 	}
 
 	/**
 	 * Returns the set mode.
 	 * 
 	 * @return
 	 */
 	public SliderSetMode getSetMode() {
 		return mode;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickParameters#measureTick(double,
 	 * java.lang.String)
 	 */
 	public int measureTick(double position, String text) {
 		if (text == null) {
 			return 0;
 		}
 
 		return getGraphics().getFontMetrics().stringWidth(text);
 	}
 
 	/**
 	 * Sets whether this slider is settable. If editable, user can change values,
 	 * otherwise UI is disabled.
 	 * 
 	 * @param settable true/false
 	 */
 	public void setEditable(boolean settable) {
 		this.settable = settable;
 		getNavigationBar().setEnabled(settable && isEnabled());
 		getInfoBar().setEnabled(settable && isEnabled());
 		slider.setEnabled(settable && isEnabled());
 	}
 
 	/**
 	 * Returns whether this slider is settable.
 	 * 
 	 * @return true/false
 	 */
 	public boolean isEditable() {
 		return settable;
 	}
 
 	/*
 	 * (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("Synchronize") {
 				private static final long serialVersionUID = 1L;
 
 				public void actionPerformed(ActionEvent e) {
 					synchronize();
 				}
 			});
 			popupManager.addAction(null);
 			popupManager.addAction(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 
 				public void actionPerformed(ActionEvent e) {
 					getCustomizer().showDialog();
 				}
 			});
 		}
 
 		return popupManager;
 	}
 
 	/**
 	 * Returns the Customizer instance for this component.
 	 * 
 	 * @return the Customizer instance for this component.
 	 */
 	public AbstractCustomizerPanel getCustomizer() {
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 
 		return customizer;
 	}
 
 	/**
 	 * Synchronized front thumb value with the shadow. Value is synchronized to the
 	 * readback.
 	 */
 	public void synchronize() {
 		synchronized (this) {
 			supressPropChEvent = supressSetEvent = true;
 			performInternalSet(getReadback());
 			supressPropChEvent = supressSetEvent = false;
 		}
 	}
 
 	/**
 	 * If in {@link SliderSetMode#SET_MANUAL} method will notify listeners that set was
 	 * performed. If in any other setMode, the call will have no effect.
 	 */
 	public void setManual() {
 		if (mode == SliderSetMode.SET_MANUAL) {
 			double oldValue = getValue();
 			double value = getRangedValue().validate(getNavigationBar().getValue());
 
 			synchronized (this) {
 				if (!supressChanges) {
 					supressChanges = true;
 
 					getAutoSyncTimer().stop();
 
 					getRangedValue().setValue(value);
 
 					if (!isSuspended()) {
 						fireSetPerformed(getValue());
 						firePropertyChange("value",oldValue,getValue());
 					}
 
 					if (autoSynchronize) {
 						getAutoSyncTimer().restart();
 					}
 
 					supressChanges = false;
 				}
 			}
 		}
 	}
 
 	/*
 	 * (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());
 
 		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()));
 	}
 
 	/**
 	 * Returns whether the user can trigger the component's popup menu through mouse
 	 * click.
 	 * 
 	 * @return true if popup is enabled
 	 */
 	public boolean isPopupEnabled() {
 		return popupEnabled;
 	}
 
 	/**
 	 * Enables or disables the popup capabilities of the component.
 	 * 
 	 * @param b the component should bring up popup dialog on mouse click.
 	 */
 	public void setPopupEnabled(boolean b) {
 		if (b == popupEnabled) return;
 		popupEnabled = b;
 		if (b) {
 			getSlider().addMouseListener(getPopupManager().getMouseHook());
 			addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			getSlider().removeMouseListener(getPopupManager().getMouseHook());
 			removeMouseListener(getPopupManager().getMouseHook());
 		}
 		firePropertyChange("popupEnabled",!b,b);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#getToolTipText()
 	 */
 	@Override
 	public String getToolTipText() {
 		StringBuffer sb = new StringBuffer();
 		sb.append("setpoint= ");
 		sb.append(getNavigationBar().format(getValue()));
 		sb.append(" readback= ");
 		sb.append(getNavigationBar().format(getReadback()));
 
 		return sb.toString();
 	}
 
 	/**
 	 * Suspends displayer, minimal GUI action is taken, no data value events fired and
 	 * slider is disabled. Call <code>resume()</code> as many times as suspend was called.
 	 */
 	public void suspend() {
 		suspended++;
 		setEnabled(false);
 	}
 
 	/**
 	 * Resumes suspended slider. Call <code>resume()</code> as many times as suspend was
 	 * called.
 	 * 
 	 * @see Slider#suspend();
 	 */
 	public void resume() {
 		if (suspended > 0) {
 			suspended--;
 		} else {
 			setEnabled(true);
 		}
 	}
 
 	/**
 	 * Returns <code>true</code> if slider is suspended
 	 * 
 	 * @return <code>true</code> if suspended
 	 * @see Slider#suspend()
 	 */
 	public boolean isSuspended() {
 		return suspended > 0;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setEnabled(boolean)
 	 */
 	@Override
 	public void setEnabled(boolean enabled) {
 		super.setEnabled(enabled);
 		getSlider().setEnabled(enabled && settable);
 		getNavigationBar().setEnabled(enabled && settable);
 		getInfoBar().setEnabled(enabled && settable);
 	}
 
 	/**
 	 * Returns the state of autoSynchronization feature (enabled / disabled).
 	 * 
 	 * @return
 	 */
 	public boolean isAutoSynchronize() {
 		return autoSynchronize;
 	}
 
 	/**
 	 * Turns the autoSynchronization on/off. If autosynchronization is on slider will
 	 * automatically synchronize the value with readback after the specified delay if no
 	 * activity was present during that time.
 	 * 
 	 * @param autoSynchronize
 	 * @see #setAutoSynchronizeDelay(long)
 	 */
 	public void setAutoSynchronize(boolean autoSynchronize) {
 		if (isAutoSynchronize() == autoSynchronize) return;
 		this.autoSynchronize = autoSynchronize;
 		if (autoSynchronize) {
 			getAutoSyncTimer().restart();
 		} else {
 			getAutoSyncTimer().stop();
 		}
 		firePropertyChange("autoSynchronize",!autoSynchronize,autoSynchronize);
 	}
 
 	/**
 	 * Returns the time in milliseconds that specify the delay of the autoSynchronization.
 	 * 
 	 * @return
 	 */
 	public long getAutoSynchronizeDelay() {
 		return autoSynchronizeDelay;
 	}
 
 	/**
 	 * Sets the autoSynchronization in miliseconds.
 	 * 
 	 * @param autoSynchronizeDelay
 	 */
 	public void setAutoSynchronizeDelay(long autoSynchronizeDelay) {
 		long oldValue = getAutoSynchronizeDelay();
 		this.autoSynchronizeDelay = autoSynchronizeDelay;
 
 		getAutoSyncTimer().setDelay((int)autoSynchronizeDelay);
 		getAutoSyncTimer().setInitialDelay((int)autoSynchronizeDelay);
 		if (autoSynchronize) {
 			getAutoSyncTimer().restart();
 		} else {
 			getAutoSyncTimer().stop();
 		}
 		firePropertyChange("autoSynchronizeDelay",oldValue,this.autoSynchronizeDelay);
 
 	}
 
 	/**
 	 * Modifies slider position. Recalculates position on JSlider's integer scale and
 	 * repaints this component.
 	 */
 	private void modifySliderPosition() {
 		getSlider().setValue((int)getRangedValue().getRelativeValue());
 		repaint();
 	}
 
 	/**
 	 * Enables/disables mouse dragging. Dragging can only be enabled if this component
 	 * uses CosyTransferHandler.
 	 * 
 	 * @param enabled
 	 */
 	public void setDragEnabled(boolean enabled) {
 		if (isDragEnabled() == enabled) return;
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			if (((CosyTransferHandler)getTransferHandler()).isExportEnabled() == enabled) return;
 
 			((CosyTransferHandler)getTransferHandler()).setExportEnabled(enabled,this);
 		}
 		firePropertyChange("dragEnabled",!enabled,enabled);
 	}
 
 	/**
 	 * Returns true if drag is enabled.
 	 * 
 	 * @return
 	 */
 	public boolean isDragEnabled() {
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			return ((CosyTransferHandler)getTransferHandler()).isExportEnabled();
 		}
 		return getTransferHandler() != null;
 	}
 
 	/**
 	 * Enable/disable the mouse drop. Drop can only be enabled if this component uses
 	 * CosyTransferHandler.
 	 * 
 	 * @param enabled
 	 */
 	public void setDropEnabled(boolean enabled) {
 		if (isDropEnabled() == enabled) return;
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			if (((CosyTransferHandler)getTransferHandler()).isReceiveEnabled() == enabled) return;
 
 			((CosyTransferHandler)getTransferHandler()).setReceiveEnabled(enabled,this);
 		}
 		firePropertyChange("dropEnabled",!enabled,enabled);
 	}
 
 	/**
 	 * Returns true if drop is enabled.
 	 * 
 	 * @return
 	 */
 	public boolean isDropEnabled() {
 		if (getTransferHandler() instanceof CosyTransferHandler) {
 			return ((CosyTransferHandler)getTransferHandler()).isReceiveEnabled();
 		}
 		return getTransferHandler() != null;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setBackground(java.awt.Color)
 	 */
 	@Override
 	public void setBackground(Color bg) {
 		super.setBackground(bg);
 		getNavigationBar().setBackground(bg);
 		getSlider().setBackground(bg);
 		getInfoBar().setBackground(bg);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setForeground(java.awt.Color)
 	 */
 	@Override
 	public void setForeground(Color fg) {
 		super.setForeground(fg);
 		getNavigationBar().setForeground(fg);
 		getSlider().setForeground(fg);
 		getInfoBar().setForeground(fg);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see com.cosylab.gui.components.range2.TickParameters#formatNumber(double)
 	 */
 	public String formatNumber(double value) {
 		return this.getFormatter().sprintf(value);
 	}
 
 	/**
 	 * Sets a text to a desired button. Text can only be set for navigation buttons and
 	 * not for 'SYNC', 'STORE' and 'RESTORE'.
 	 * 
 	 * @param b <code>Button</code> to which a text we want to set.
 	 * @param text <code>String</code> containing a text for a <code>Button</code>.
 	 */
 	public void setButtonText(Button b, String text) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			getNavigationBar().setButtonText(b,text);
 		}
 	}
 
 	/**
 	 * Sets a Icon to a desired button. Icon can only be set for navigation buttons and
 	 * not for 'SYNC', 'STORE' and 'RESTORE'.
 	 * 
 	 * @param b <code>Button</code> to which a text we want to set.
 	 * @param icon <code>Icon</code> containing a text for a <code>Button</code>.
 	 */
 	public void setButtonIcon(Button b, Icon icon) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			getNavigationBar().setButtonIcon(b,icon);
 		}
 	}
 
 	/**
 	 * Returns the text of a desired button.
 	 * 
 	 * @param b <code>Button</code> of which a text we want to get.
 	 * @return <code>String</code> containing the text for a <code>Button</code> if the
 	 *         text is set.
 	 */
 	public String getButtonText(Button b) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			return getNavigationBar().getButtonText(b);
 		}
 		return null;
 	}
 
 	/**
 	 * Returns the Icon of a desired button.
 	 * 
 	 * @param b <code>Button</code> of which an Icon we want to get.
 	 * @return <code>String</code> containing the Icon for a <code>Button</code> if the
 	 *         Icon is set.
 	 */
 	public Icon getButtonIcon(Button b) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			return getNavigationBar().getButtonIcon(b);
 		}
 		return null;
 	}
 
 	/**
 	 * Sets a tooltip to a desired button. Tooltips can only be set for navigation buttons
 	 * and not for 'SYNC', 'STORE' and 'RESTORE'.
 	 * 
 	 * @param b <code>Button</code> to which a tooltip we want to set.
 	 * @param tooltip <code>String</code> containing a tooltip for a <code>Button</code>.
 	 */
 	public void setButtonTooltip(Button b, String tooltip) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			getNavigationBar().setButtonTooltip(b,tooltip);
 		}
 	}
 
 	/**
 	 * Returns the tooltip of a desired button.
 	 * 
 	 * @param b <code>Button</code> of which a tooltip we want to get.
 	 * @return <code>String</code> containing a tooltip for a <code>Button</code> if a
 	 *         tooltip is set.
 	 */
 	public String getButtonTooltip(Button b) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			return getNavigationBar().getButtonTooltip(b);
 		}
 		return null;
 	}
 
 	/**
 	 * Toggles the visibility of the specified button.
 	 * 
 	 * @param b button to be set visible/invisible
 	 * @param visible true if button should be visible
 	 */
 	public void setButtonVisible(Button b, boolean visible) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			getNavigationBar().setButtonVisible(b,visible);
 		}
 	}
 
 	/**
 	 * Returns the visibility of a button.
 	 * 
 	 * @param b button
 	 * @return true if button b is visible
 	 */
 	public boolean isButtonVisible(Button b) {
 		if (b == Button.FAST_INCREMENT || b == Button.FAST_DECREMENT || b == Button.SLOW_INCREMENT || b == Button.SLOW_DECREMENT
 				|| b == Button.BIT_INCREMENT || b == Button.BIT_DECREMENT) {
 			return getNavigationBar().isButtonVisible(b);
 		}
 		return false;
 	}
 
 	/**
 	 * Sets the store and restore buttons visibile/invisible.
 	 * 
 	 * @param visible visiblity of storage buttons
 	 */
 	public void setStorageButtonsVisible(boolean visible) {
 		if (isStorageButtonsVisible() == visible) return;
 		getInfoBar().setStorageButtonsVisible(visible);
 		firePropertyChange("storageButtonsVisible",!visible,visible);
 	}
 
 	/**
 	 * Returns true if the stored value label is set to be visible. Label can be actually
 	 * shown only when storage buttons are visible.
 	 * 
 	 * @param visible visiblity of stored value label
 	 * @see Slider#isStorageButtonsVisible()
 	 */
 	public boolean isStoredValueLabelVisible() {
 		return getInfoBar().isStoredValueLabelVisible();
 	}
 
 	/**
 	 * Sets the stored value label to be visible. Label can be only wisible, when storage
 	 * buttons are visible.
 	 * 
 	 * @param visible visiblity of storage buttons
 	 * @see Slider#setStorageButtonsVisible(boolean)
 	 */
 	public void setStoredValueLabelVisible(boolean visible) {
 		if (isStoredValueLabelVisible() == visible) return;
 		getInfoBar().setStoredValueLabelVisible(visible);
 		firePropertyChange("storedValueLabelVisible",!visible,visible);
 	}
 
 	/**
 	 * Returns the visibility flag of the store and restore buttons.
 	 * 
 	 * @return true if buttons are visible
 	 */
 	public boolean isStorageButtonsVisible() {
 		return getInfoBar().isStorageButtonsVisible();
 	}
 
 	/**
 	 * Sets the sync button visibile/invisible.
 	 * 
 	 * @param visible visiblity of storage buttons
 	 */
 	public void setSyncButtonVisible(boolean visible) {
 		if (isSyncButtonVisible() == visible) return;
 		getInfoBar().setSyncButtonVisible(visible);
 		getSliderUI().setPaintTrailer(visible);
 		firePropertyChange("syncButtonVisible",!visible,visible);
 	}
 
 	/**
 	 * Returns the visibility flag of the sync button.
 	 * 
 	 * @return true if button is visible
 	 */
 	public boolean isSyncButtonVisible() {
 		return getInfoBar().isSyncButtonVisible();
 	}
 
 	/**
 	 * Sets the tolerance at which the thumb is considered to be synchronized with the
 	 * trailer.
 	 * 
 	 * @param precision
 	 * @see CosySliderUI#setTolerance(double)
 	 */
 	public void setValuePrecision(double precision) {
 		getSliderUI().setTolerance(precision);
 	}
 
 	/**
 	 * Returns the tolerance for current value set via slider.
 	 * 
 	 * @return precision <code>Double</code> precision value
 	 * @see CosySliderUI#getTolerance()
 	 */
 	public double getValuePrecision() {
 		return getSliderUI().getTolerance();
 	}
 
 	/**
 	 * Sets the font used to display the title of the slider.
 	 * 
 	 * @param font new font
 	 */
 	public void setTitleFont(Font font) {
 		Font oldFont = getTitleFont();
 		getInfoBar().setFont(font);
 		firePropertyChange("titleFont",oldFont,font);
 	}
 
 	/**
 	 * Returns the font used to display the title.
 	 * 
 	 * @return
 	 */
 	public Font getTitleFont() {
 		return getInfoBar().getFont();
 	}
 
 	/**
 	 * Sets the font used to display the units.
 	 * 
 	 * @param font new font
 	 */
 	public void setUnitsFont(Font font) {
 		Font oldFont = getUnitsFont();
 		getNavigationBar().setUnitsFont(font);
 		firePropertyChange("unitsFont",oldFont,font);
 	}
 
 	/**
 	 * Returns the font used to display units.
 	 * 
 	 * @return
 	 */
 	public Font getUnitsFont() {
 		return getNavigationBar().getFont();
 	}
 
 	/**
 	 * Returns the values which are painted together with majot ticks.
 	 * 
 	 * @return
 	 */
 	public double[] getMajorTicks() {
 		return manualTickProvider.getMajorTicks();
 	}
 
 	/**
 	 * Returns the values which have labeles painted next to the tick. Only major ticks
 	 * can have labels.
 	 * 
 	 * @return
 	 */
 	public double[] getMajorTickLabels() {
 		return manualTickProvider.getLabels();
 	}
 
 	/**
 	 * Returns the distance between two minor ticks in same units as value.
 	 * 
 	 * @return
 	 */
 	public double getMinorTicksStep() {
 		return manualTickProvider.getMinor();
 	}
 
 	/**
 	 * Explicitely sets which values on the slider scale should be painted with major
 	 * ticks.
 	 * 
 	 * @param ticks
 	 */
 	public void setMajorTicks(double[] ticks) {
 		double[] oldValue = getMajorTicks();
 		manualTickProvider.setMajorTicks(ticks);
 		if (ticks != null) {
 			getRangedValue().setTickCalculator(manualTickProvider);
 		} else {
 			getRangedValue().setTickCalculator(null);
 		}
 		repaint();
 		firePropertyChange("majorTicks",oldValue,ticks);
 	}
 
 	/**
 	 * Sets the distance between two minor ticks in same units as value.
 	 * 
 	 * @param ticks
 	 */
 	public void setMinorTicksStep(double step) {
 		double oldValue = getMinorTicksStep();
 		if (oldValue == step) return;
 		manualTickProvider.setMinor(step);
 		firePropertyChange("minorTicksNumber",oldValue,step);
 		if (getMajorTicks() != null) repaint();
 	}
 
 	/**
 	 * Explicitely sets which major ticks will have value labels painted. If any of the
 	 * labels in this array is not a major tick, that value will be ignored.
 	 * 
 	 * @param labelledTicks
 	 */
 	public void setMajorTickLabels(double[] labelledTicks) {
 		double[] oldValue = getMajorTickLabels();
 		manualTickProvider.setLabels(labelledTicks);
 		firePropertyChange("majorTickLabels",oldValue,labelledTicks);
 		if (getMajorTicks() != null) repaint();
 	}
 
 	/**
 	 * Returns the stored value. If no value was stored Double.NaN is returned.
 	 * 
 	 * @return stored value
 	 */
 	public double getStoredValue() {
 		return storedValue;
 	}
 
 	/**
 	 * Stores new value. The stored value can be restored at any later time provided that
 	 * is has not been override by a different value.
 	 * 
 	 * @param storedValue new stored value
 	 * @see Slider#restoreValue();
 	 */
 	public void setStoredValue(double storedValue) {
 		if (this.storedValue == storedValue) return;
 		double oldValue = this.storedValue;
 		this.storedValue = storedValue;
 		if (Double.isNaN(storedValue)) {
 			getInfoBar().setStoredValue(null);
 		} else {
 			getInfoBar().setStoredValue(getNavigationBar().format(storedValue));
 		}
 		firePropertyChange("storedValue",oldValue,storedValue);
 	}
 
 	/**
 	 * Stores the current setpoint value.
 	 */
 	public void storeValue() {
 		setStoredValue(getValue());
 	}
 
 	/**
 	 * Restores the stored value. Value is set to the slider. This method has the same
 	 * effect as {@link #setValue(double)} where the parameter is
 	 * {@link #getStoredValue()}.
 	 */
 	public void restoreValue() {
 		if (Double.isNaN(getStoredValue())) return;
 		performInternalSet(getStoredValue());
 	}
 
 	/**
 	 * Sets the title of the restore button.
 	 * 
 	 * @param title new title
 	 */
 	public void setRestoreButtonTitle(String title) {
 		String oldValue = getRestoreButtonTitle();
 		if (oldValue != null && oldValue.equals(title)) return;
 		getInfoBar().setRestoreButtonTitle(title);
 		firePropertyChange("restoreButtonTitle",oldValue,title);
 	}
 
 	/**
 	 * Returns the title of the restore button.
 	 * 
 	 * @return the title
 	 */
 	public String getRestoreButtonTitle() {
 		return getInfoBar().getRestoreButtonTitle();
 	}
 
 	/**
 	 * Returns the initial delay time after button press to first auto increment/decrement
 	 * 
 	 * @return the continuousModeDelayTime
 	 */
 	public int getContinuousModeDelayTime() {
 		return getNavigationBar().getContinuousModeDelayTime();
 	}
 
 	/**
 	 * Sets the initial delay time in milliseconds betwean button pressed and hold for
 	 * increment/decrement and continuous mode is fired.
 	 * 
 	 * @param the continuousModeDelayTime in milliseconds
 	 */
 	public void setContinuousModeDelayTime(int continuousModeDelayTime) {
 		if (getContinuousModeDelayTime() == continuousModeDelayTime) return;
 		int old = getContinuousModeDelayTime();
 		getNavigationBar().setContinuousModeDelayTime(continuousModeDelayTime);
 		firePropertyChange("continuousModeDelayTime",old,continuousModeDelayTime);
 	}
 
 	/**
 	 * Returns continuousModeEnabled
 	 * 
 	 * @return the continuousModeDelayTime
 	 */
 	public boolean isContinuousModeEnabled() {
 		return continuousModeEnabled;
 	}
 
 	/**
 	 * Sets the continuousModeEnabled and updates combobox on InfoBar to appropriate index
 	 * 
 	 * @param the continuousModeEnabled
 	 */
 	public void setContinuousModeEnabled(boolean continuousModeEnabled) {
 		if (this.continuousModeEnabled == continuousModeEnabled) return;
 		this.continuousModeEnabled = continuousModeEnabled;
 		this.getInfoBar().setContinuousMode(continuousModeEnabled);
 		firePropertyChange("continuousModeEnabled",!continuousModeEnabled,continuousModeEnabled);
 	}
 
 	/**
 	 * Returns the continuousModeEnabled
 	 * 
 	 * @return the continuousModeEnabled
 	 */
 	public int getContinuousModeRepeatTime() {
 		return getNavigationBar().getContinuousModeRepeatTime();
 	}
 
 	/**
 	 * Sets the continuousModeRepeatTime time in milliseconds between individual
 	 * repetitions of contunuous increment/decrement.
 	 * 
 	 * @param the continuousModeRepeatTime in milliseconds
 	 */
 	public void setContinuousModeRepeatTime(int continuousModeRepeatTime) {
 		if (getContinuousModeRepeatTime() == continuousModeRepeatTime) return;
 		int old = getContinuousModeRepeatTime();
 		getNavigationBar().setContinuousModeRepeatTime(continuousModeRepeatTime);
 		firePropertyChange("continuousModeRepeatTime",old,continuousModeRepeatTime);
 	}
 
 	/**
 	 * Sets visibility of control ofr continuous mode.
 	 * 
 	 * @param the continuousControlVisible
 	 */
 	public void setContinuousControlVisible(boolean continuousControlVisible) {
 		if (this.continuousControlVisible == continuousControlVisible) return;
 		this.continuousControlVisible = continuousControlVisible;
 		this.getInfoBar().setContinuousModeVisible(continuousControlVisible);
 		firePropertyChange("continuousControlVisible",!continuousControlVisible,continuousControlVisible);
 	}
 	
 	/**
 	 * Returns <code>true</code> if contunyous mode checkbox is visible.
 	 * 
 	 * @return the isShowContinuousMode
 	 */
 	public boolean isContinuousControlVisible() {
 		return continuousControlVisible;
 	}
 
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setToolTipText(java.lang.String)
 	 */
 	@Override
 	public void setToolTipText(String tooltip) {
 		super.setToolTipText(tooltip);
 
 		this.slider.setToolTipText(tooltip);
 		this.getInfoBar().setToolTipText(tooltip);
 		this.getNavigationBar().setToolTipText(tooltip);
 	}
 
 	/**
 	 * Sets the snap to ticks property. If true the slider thumb can be moved on discrete
 	 * values defined by the slider ticks.
 	 * 
 	 * @param snapToTicks true if thumb should snap to ticks
 	 */
 	public void setSnapToTicks(boolean snapToTicks) {
 		if (this.snapToTicks == snapToTicks) return;
 		this.snapToTicks = snapToTicks;
 		firePropertyChange("snapToTicks",!snapToTicks, snapToTicks);
 		getRangedValue().setSnapToTicks(snapToTicks);
 	}
 	
 	/**
 	 * Returns true if snap to ticks is turned on.
 	 * 
 	 * @see #setSnapToTicks(boolean)
 	 * @return true if snap is turned on
 	 */
 	public boolean isSnapToTicks() {
 		return snapToTicks;
 	}
 	
 	
 	/**
 	 * Run test applet.
 	 * 
 	 * @param args command line parameters
 	 */
 	public static void main(String[] args) {
 		Slider sliderAmplitude = new Slider();
 		sliderAmplitude.setPopupEnabled(true);
 		sliderAmplitude.setTitle("Some title");
 		sliderAmplitude.setToolTipText("Some tool tip text");
 		sliderAmplitude.setUnits("Some unit");
 		sliderAmplitude.setUnitsVisible(true);
 		sliderAmplitude.setStorageButtonsVisible(true);
 		sliderAmplitude.setStoredValue(0.0f);
 		sliderAmplitude.setRestoreButtonTitle("OLD");
 		sliderAmplitude.setSyncButtonVisible(false);
 		sliderAmplitude.setAutoSynchronize(false);
 		sliderAmplitude.setFormat("%3.2f");
 		sliderAmplitude.setTicksFormat("%3.4f");
 //		sliderAmplitude.setMajorTicks(new double[] {0.0, 10.0, 20.0, 30.0, 40.0,
 //		50.0, 60.0, 70.0, 80.0, 90.0, 100.0});
 //		sliderAmplitude.setMajorTickLabels(new double[] {0.0, 10.0, 20.0, 30.0,
 //		40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0});
 		sliderAmplitude.setMinimum(0.0);
 		sliderAmplitude.setMaximum(100.0);
 		RunnerHelper.runComponent(sliderAmplitude, 400,400);
 	}
 
 }
 
 /* __oOo__ */