/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.displayers.chart;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.Graphics;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Insets;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.ItemEvent;
  import java.awt.event.ItemListener;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  
  import javax.swing.DefaultListCellRenderer;
  import javax.swing.Icon;
  import javax.swing.JButton;
  import javax.swing.JCheckBox;
  import javax.swing.JComboBox;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.ListCellRenderer;
  import javax.swing.event.EventListenerList;
  
  import de.desy.acop.chart.AcopGraphStyleEnum;
  
  /**
   * <code>ScalePanel</code> is a visual bean which allows selection and configuration
   * of certain chart scaling properties. This bean is independent of any chart
   * and only supplies the certain components for setting properties. Upon the change
   * of any of the properties a <code>PropertyChangeEvent</code> is fired which notifies
   * all registered listeners.
   *  
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   * @version $Id: Templates.xml,v 1.10 2004/01/13 16:17:13 jbobnar Exp $
   *
   */
  public class ScalePanel extends JPanel {
  	
  	private static final long serialVersionUID = 1L;
  	private JButton defaultScaleButton;
  	private JCheckBox autoScaleCheckBox;
  	private JComboBox linLogCombo;
  	private JLabel logCriticalLabel;
  	private JButton paneUpButton;
  	private JButton paneDownButton;
  	private JButton zoomInButton;
  	private JButton zoomOutButton;
  	private MinMaxPanel minMaxPanel;
  
  	public static final String CLEAR_CMD = "clear";
  	public static final String DEFAULT_SCALE_CMD = "defaultScale";
  	public static final String PANE_DOWN_ACTION = "down";
  	public static final String PANE_UP_ACTION = "up";
  	public static final String ZOOM_IN_ACTION = "zoomIn";
  	public static final String ZOOM_OUT_ACTION = "zoomOut";
  	private static final String LOG_CRITICAL = "Log not avail.";
  	
  	private AcopGraphStyleEnum selectedStyle = AcopGraphStyleEnum.LinLin;
  	private AcopGraphStyleEnum[] availableStyles = AcopGraphStyleEnum.values();
  	private boolean logCritical = false;
  	private boolean autoScale = false;
  	private boolean relativeScaleMode = false;
  	private double defaultMin = 0;
  	private double defaultMax = 0;
  	private boolean minMaxEnabled = true;
  	
  	private EventListenerList listenerList = new EventListenerList();
  	
  	private double forcedDx = 1;
  	
  	/**
  	 * Constructs a new ScalePanel.
  	 *
  	 */
 	public ScalePanel() {
 		super();
 		initialize();
 	}
 	
 	private void initialize() {
 		setLayout(new GridBagLayout());
 		
 		JPanel shiftZoomPanel = new JPanel(new GridBagLayout());
 		
 		paneDownButton = new JButton(getUpDownIcon(0));
 		paneDownButton.setToolTipText("Pane down");
 		paneDownButton.setActionCommand(PANE_DOWN_ACTION);
 		paneDownButton.addActionListener(new ActionListener(){
 			public void actionPerformed(ActionEvent e) {
 				if (isAutoScale()) setAutoScale(false);
 				double dx = forcedDx*(getMinMaxPanel().getMax() - getMinMaxPanel().getMin())/10;
 				getMinMaxPanel().setMax(getMax() + dx);
 				getMinMaxPanel().setMin(getMin() + dx);
 				getMinMaxPanel().setRescaleEnabled(false);
 				fireActionEvent(e);
 			}
 		});
 		shiftZoomPanel.add(paneDownButton, new GridBagConstraints(3, 0, 1, 1, 1, 1, 14, 0, new Insets(2, 2, 2, 2), 0, 0));
 		
 		
 		paneUpButton = new JButton(getUpDownIcon(1));
 		paneUpButton.setToolTipText("Pane up");
 		paneUpButton.setActionCommand(PANE_UP_ACTION);
 		paneUpButton.addActionListener(new ActionListener(){
 			public void actionPerformed(ActionEvent e) {
 				if (isAutoScale()) setAutoScale(false);
 				double dx = forcedDx*(getMinMaxPanel().getMax() - getMinMaxPanel().getMin())/10;
 				getMinMaxPanel().setMax(getMax() - dx);
 				getMinMaxPanel().setMin(getMin() - dx);
 				getMinMaxPanel().setRescaleEnabled(false);
 				fireActionEvent(e);
 			}
 		});
 		shiftZoomPanel.add(paneUpButton, new GridBagConstraints(2, 0, 1, 1, 1, 1, 14, 0, new Insets(2, 2, 2, 2), 0, 0));
 		
 		zoomInButton = new JButton(getUpDownIcon(2));
 		zoomInButton.setToolTipText("Zoom in");
 		zoomInButton.setActionCommand(ZOOM_IN_ACTION);
 		zoomInButton.addActionListener(new ActionListener(){
 			public void actionPerformed(ActionEvent e) {
 				if (isAutoScale()) setAutoScale(false);
 				double dx = forcedDx*(getMinMaxPanel().getMax() - getMinMaxPanel().getMin())/22;
 				double max = getMax() - dx;
 				double min = getMin() + dx;
 				//java has some rounding problems from time to time. in such cases just reset the value to 0
 				if (Math.abs(max) < 1E-16) {
 					max = 0;
 				}
 				if (Math.abs(min) < 1E-16) {
 					min = 0;
 				}
 				getMinMaxPanel().setMax(max);
 				getMinMaxPanel().setMin(min);
 				getMinMaxPanel().setRescaleEnabled(false);
 				fireActionEvent(e);
 			}
 		});
 		shiftZoomPanel.add(zoomInButton, new GridBagConstraints(0, 0, 1, 1, 1, 1, 14, 0, new Insets(2, 2, 2, 2), 0, 0));
 		
 		zoomOutButton = new JButton(getUpDownIcon(3));
 		zoomOutButton.setToolTipText("Zoom out");
 		zoomOutButton.setActionCommand(ZOOM_OUT_ACTION);
 		zoomOutButton.addActionListener(new ActionListener(){
 			public void actionPerformed(ActionEvent e) {
 				if (isAutoScale()) setAutoScale(false);
 				double dx = forcedDx*(getMinMaxPanel().getMax() - getMinMaxPanel().getMin())/20;;
 				double max = getMax() + dx;
 				double min = getMin() - dx;
 				//java has some rounding problems from time to time. in such cases just reset the value to 0
 				if (Math.abs(max) < 1E-16) {
 					max = 0;
 				}
 				if (Math.abs(min) < 1E-16) {
 					min = 0;
 				}
 				getMinMaxPanel().setMax(max);
 				getMinMaxPanel().setMin(min);
 				getMinMaxPanel().setRescaleEnabled(false);
 				fireActionEvent(e);
 			}
 		});
 		shiftZoomPanel.add(zoomOutButton, new GridBagConstraints(1, 0, 1, 1, 1, 1, 14, 0, new Insets(2, 2, 2, 2), 0, 0));
 		
 		this.add(shiftZoomPanel, new GridBagConstraints(0,0,3,1,0,0,GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, new Insets(2,4,2,2),0,0));
 			
 		this.add(getMinMaxPanel(), new GridBagConstraints(0,1,1,2,1,0,GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH, new Insets(2,4,2,2),0,0));
 		
 		JPanel rightPanel = new JPanel(new GridBagLayout());
 		
 		linLogCombo = new JComboBox(availableStyles);		
 		linLogCombo.addItemListener(new ItemListener(){
 			public void itemStateChanged(ItemEvent e) {
 				if (e.getStateChange() == ItemEvent.SELECTED) {
 					setStyle((AcopGraphStyleEnum)linLogCombo.getSelectedItem());
 				} 
 			}
 		});
 		linLogCombo.setMinimumSize(new Dimension(80,21));
 		linLogCombo.setPreferredSize(new Dimension(80,21));
 		linLogCombo.setToolTipText("Scale Type of the Trace");
 		
 		rightPanel.add(linLogCombo, new GridBagConstraints(0,0,1,1,1,0,GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(2,2,2,4),0,0));
 		
 		logCriticalLabel = new JLabel(" ");
 		logCriticalLabel.setOpaque(true);
 		rightPanel.add(logCriticalLabel, new GridBagConstraints(0,1,1,1,1,0,GridBagConstraints.SOUTHEAST, GridBagConstraints.NONE, new Insets(2,2,2,4),0,0));
 //		logCriticalLabel.setVisible(false);
 
 		this.add(rightPanel, new GridBagConstraints(1,1,1,2,1,0,GridBagConstraints.NORTHEAST, GridBagConstraints.NONE, new Insets(2,4,2,2),0,0));
 		
 		defaultScaleButton = new JButton("Default Scale");
 		defaultScaleButton.setActionCommand(ScalePanel.DEFAULT_SCALE_CMD);
 		defaultScaleButton.addActionListener(new ActionListener(){
 			public void actionPerformed(ActionEvent e) {
 				setAutoScale(false);
 				if (getMax() != getDefaultMax()) {
 					setMax(getDefaultMax());
 				} else {
 					firePropertyChange("max", null, getMax());
 				}
 				if (getMin() != getDefaultMin()) {
 					setMin(getDefaultMin());
 				} else {
 					firePropertyChange("min", null, getMin());
 				}
 			}
 		});
 		defaultScaleButton.setToolTipText("Apply Default Scale");
 		
 		this.add(defaultScaleButton, new GridBagConstraints(0,3,1,1,1,0,GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(2,4,4,2),0,0));
 
 		autoScaleCheckBox = new JCheckBox("Auto Scale");
 		autoScaleCheckBox.setHorizontalTextPosition(JCheckBox.LEADING);
 		autoScaleCheckBox.addItemListener(new ItemListener(){
 			public void itemStateChanged(ItemEvent e) {
 				setAutoScale(autoScaleCheckBox.isSelected());
 			}
 		});
 		autoScaleCheckBox.setEnabled(false);
 		autoScaleCheckBox.setToolTipText("Toggle Optimal Autoscale");
 		this.add(autoScaleCheckBox, new GridBagConstraints(1,3,1,1,1,0,GridBagConstraints.EAST, GridBagConstraints.NONE, new Insets(2,2,2,0),0,0));
 		
 		
 	}
 	
 	private MinMaxPanel getMinMaxPanel() {
 		if (minMaxPanel == null) {
 			minMaxPanel = new MinMaxPanel();
 			minMaxPanel.addPropertyChangeListener(new PropertyChangeListener(){
 				public void propertyChange(PropertyChangeEvent evt) {
 					String name = evt.getPropertyName();
 					if ("max".equals(name) || "min".equals(name) && minMaxEnabled) {
 						firePropertyChange(name, evt.getOldValue(), evt.getNewValue());
 					}
 				}
 			});
 		}
 		return minMaxPanel;
 	}
 	
 	/**
 	 * Sets the flag whether extra digits are shown on this panel or not. If true
 	 * the precision of all numbers is larger than if false.
 	 * 
 	 * @param extraDigits true if high precision should be used
 	 */
 	public void setExtraDigits(boolean extraDigits) {
 		if (isExtraDigits() == extraDigits) return;
 		getMinMaxPanel().setExtraDigits(extraDigits);
 		firePropertyChange("extraDigits", !extraDigits, extraDigits);
 	}
 	
 	/**
 	 * Returns true if this panel shows extra digits.
 	 * 
 	 * @return true if extra digits are shown
 	 */
 	public boolean isExtraDigits() {
 		return getMinMaxPanel().isExtraDigits();
 	}
 	
 	/**
 	 * Adds the action listener which is notified when pane up or down is pressed.
 	 * 
 	 * @param l the listener to add
 	 */
 	public void addActionListener(ActionListener l) {
 		listenerList.add(ActionListener.class,l);
 	}
 	
 	/**
 	 * Removes the action listener.
 	 * 
 	 * @param l the listener to remove
 	 */
 	public void removeActionListener(ActionListener l) {
 		listenerList.remove(ActionListener.class,l);
 	}
 	
 	/**
 	 * Notifies all registered action listeners about the event that ocurred.
 	 * 
 	 * @param e the event
 	 */
 	private void fireActionEvent(ActionEvent e) {
 		Object[] listeners = listenerList.getListenerList();
 		for (int i = 0; i < listeners.length; i+=2) {
 			if (listeners[i] == ActionListener.class) {
 				((ActionListener)listeners[i+1]).actionPerformed(e);
 			}
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setEnabled(boolean)
 	 */
 	@Override
 	public void setEnabled(boolean e) {
 		super.setEnabled(e);
 		getMinMaxPanel().setEnabled(e & relativeScaleMode & minMaxEnabled);
 		autoScaleCheckBox.setEnabled(e & relativeScaleMode);
 		defaultScaleButton.setEnabled(e & relativeScaleMode);
 		linLogCombo.setEnabled(e & !logCritical);
 		paneDownButton.setEnabled(e & relativeScaleMode);
 		paneUpButton.setEnabled(e & relativeScaleMode);
 		zoomInButton.setEnabled(e & relativeScaleMode);
 		zoomOutButton.setEnabled(e & relativeScaleMode);
 	}	
 	
 	/**
 	 * Returns the auto scale property value.
 	 * @return the auto scale
 	 */
 	public boolean isAutoScale() {
 		return autoScaleCheckBox.isSelected();
 	}
 	
 	/**
 	 * Sets the auto scale property.
 	 * 
 	 * @param auto new auto scale value
 	 */
 	public void setAutoScale(boolean auto) {
 		if (this.autoScale == auto) return;
 		boolean oldAutoScale = this.autoScale;
 		this.autoScale = auto;
 		autoScaleCheckBox.setSelected(this.autoScale);
 		firePropertyChange("autoScale", oldAutoScale, this.autoScale);
 	}
 	
 	/**
 	 * Sets the relative scale mode. The majority of properties is enabled
 	 * only when in the relative scale mode.
 	 * 
 	 * @param relative 
 	 */
 	public void setRelativeScaleMode(boolean relative) {
 		if (relativeScaleMode == relative) return;
 		this.relativeScaleMode = relative;
 		boolean enabled = isEnabled();
 		autoScaleCheckBox.setEnabled(enabled & relative);
 		minMaxPanel.setEnabled(enabled & relative & minMaxEnabled);
 		zoomInButton.setEnabled(enabled & relative);
 		zoomOutButton.setEnabled(enabled & relative);
 		paneDownButton.setEnabled(enabled & relative);
 		paneUpButton.setEnabled(enabled & relative);
 		defaultScaleButton.setEnabled(enabled & relative);
 		linLogCombo.setEnabled(isEnabled() & !logCritical);
 		firePropertyChange("relativeScaleMode", !relative, relative);
 	}
 	
 	/**
 	 * Enables/disables the input panel for minimum and maximum.
 	 * 
 	 * @param enabled
 	 */
 	public void setMinMaxEnabled(boolean enabled) {
 		if (this.minMaxEnabled == enabled) return;
 		this.minMaxEnabled = enabled;
 		minMaxPanel.setEnabled(isEnabled() & relativeScaleMode & minMaxEnabled);
 		firePropertyChange("minMaxEnabled", !enabled, enabled);
 	}
 	
 	/**
 	 * Returns the relative scale mode.
 	 * 
 	 * @return relative scale mode
 	 */
 	public boolean getRelativeScaleMode() {
 		return relativeScaleMode;
 	}
 
 	/**
 	 * Returns true if log critical warning is shown.
 	 * @return true if critical for logarithmic values
 	 */
 	public boolean isLogCritical() {
 		return logCritical;
 	}
 
 	/**
 	 * Shows/hides label showing a warning that data is logarithmically critical.
 	 * @param logCritical
 	 */
 	public void setLogCritical(boolean logCritical) {
 		if (this.logCritical == logCritical) return;
 		this.logCritical = logCritical;
 		if (logCritical) {
 			logCriticalLabel.setText(LOG_CRITICAL);
 		} else {
 			logCriticalLabel.setText(" ");
 		}
 		linLogCombo.setEnabled(isEnabled() & !logCritical);
 		firePropertyChange("logCritical", !logCritical, logCritical);
 	}
 
 	/**
 	 * Returns the maximum value.
 	 * @return the max
 	 */
 	public double getMax() {
 		return getMinMaxPanel().getMax();
 	}
 
 	/**
 	 * Sets maximum value.
 	 * @param max new maximum value
 	 */
 	public void setMax(double max) {
 		getMinMaxPanel().setMax(max);
 	}
 	
 	/**
 	 * Sets the maximum value and notifies the listeners of property change if
 	 * requested.
 	 * 
 	 * @param max new maximum value
 	 * @param notify should listeners be notified
 	 */
 	public void setMax(double max, boolean notify) {
 		getMinMaxPanel().setMax(max, notify);
 	}
 
 	/**
 	 * Returns the minimum value.
 	 * @return the minimum value
 	 */
 	public double getMin() {
 		return getMinMaxPanel().getMin();
 	}
 
 	/**
 	 * Sets the minimum.
 	 * @param min ne wminimum value
 	 */
 	public void setMin(double min) {
 		getMinMaxPanel().setMin(min);
 	}
 	
 	/**
 	 * Sets the minimum value and notifies the listeners of property change if
 	 * requested.
 	 * 
 	 * @param min new minimum value
 	 * @param notify should listeners be notified
 	 */
 	public void setMin(double min, boolean notify) {
 		getMinMaxPanel().setMin(min, notify);
 	}
 
 	/**
 	 * Returns the default maximum value.
 	 * @return the defaultMax
 	 */
 	public double getDefaultMax() {
 		return defaultMax;
 	}
 
 	/**
 	 * Sets the default maximum value.
 	 * @param defaultMax new default maximum
 	 */
 	public void setDefaultMax(double defaultMax) {
 		if (this.defaultMax == defaultMax) return;
 		double oldValue = getDefaultMax();
 		this.defaultMax = defaultMax;
 		firePropertyChange("defaultMax", oldValue, getDefaultMax());
 	}
 
 	/**
 	 * Returns the default minimum value.
 	 * @return the defaultMin
 	 */
 	public double getDefaultMin() {
 		return defaultMin;
 	}
 
 	/**
 	 * Sets the default minimum value.
 	 * @param defaultMin new default minimum
 	 */
 	public void setDefaultMin(double defaultMin) {
 		if (this.defaultMin == defaultMin) return;
 		double oldValue = getDefaultMin();
 		this.defaultMin = defaultMin;
 		firePropertyChange("defaultMin", oldValue, getDefaultMin());
 	}
 
 	/**
 	 * Return the style selected in the combo.
 	 * @return return the selected axis scale 
 	 */
 	public AcopGraphStyleEnum getStyle() {
 		return selectedStyle;
 	}
 
 	/**
 	 * Sets selected style. The selected style needs to be one of the avaialble styles.
 	 * @param style new style
 	 */
 	public void setStyle(AcopGraphStyleEnum style) {
 		if (this.selectedStyle == style) return;
 		boolean ok = false;
 		for (AcopGraphStyleEnum s : availableStyles) {
 			if (s.equals(style)) {
 				ok = true;
 			}
 		}
 		if (!ok) return;
 		AcopGraphStyleEnum oldValue = this.selectedStyle;
 		this.selectedStyle = style;
 		linLogCombo.setSelectedItem(this.selectedStyle);
 		firePropertyChange("style", oldValue, this.selectedStyle);
 	}
 	
 	/**
 	 * Sets the styles which are available for selection.
 	 * 
 	 * @param styles
 	 */
 	public void setAvailableStyles(AcopGraphStyleEnum[] styles) {
 		AcopGraphStyleEnum[] oldValue = this.availableStyles;
 		availableStyles = styles;
 		linLogCombo.removeAllItems();
 		for (AcopGraphStyleEnum s : availableStyles) {
 			linLogCombo.addItem(s);
 		}
 		firePropertyChange("availableStyles", oldValue, availableStyles);
 	}
 	
 	/**
 	 * Returns the styles which are available for selection.
 	 * 
 	 * @return
 	 */
 	public AcopGraphStyleEnum[] getAvailableStyles() {
 		return availableStyles;
 	}
 	
 	/**
 	 * Sets the style combo renderer. The renderer should expect
 	 * the values to be of type {@link AcopGraphStyleEnum}.
 	 * 
 	 * @param renderer the renderer to used in combo
 	 */
 	public void setStyleComboRenderer(ListCellRenderer renderer) {
 		if (renderer != null) {
 			linLogCombo.setRenderer(renderer);
 		} else {
 			linLogCombo.setRenderer(new DefaultListCellRenderer());
 		}
 	}
 	
 	/**
 	 * Generates icon with up or down arrow. 
 	 * 
 	 * @param i if i == 0, down arrow is returned, if i == 1, up arrow is returned, if i == 2, "+" icon is returned, else "-" icon is returned
 	 * @return arrow icon
 	 */
 	private Icon getUpDownIcon(int i){
 		switch(i){
 		case 0:
 			// down arrow
 			return new Icon(){
 				public int getIconHeight() {
 					return 10;
 				}
 				public int getIconWidth() {
 					return 10;
 				}
 				public void paintIcon(Component c, Graphics g, int x, int y) {
 					if (!c.isEnabled())g.setColor(Color.LIGHT_GRAY);
 					else g.setColor(c.getForeground());
 					g.drawLine(x, y + 4, x + 4, y + 8);
 					g.drawLine(x + 4, y + 8, x + 8, y + 4);
 					g.drawLine(x + 4, y, x + 4, y + 8);
 				}
 			};
 		
 		case 1:
 			// up arrow
 			return new Icon(){
 				public int getIconHeight() {
 					return 10;
 				}
 				public int getIconWidth() {
 					return 10;
 				}
 				public void paintIcon(Component c, Graphics g, int x, int y) {
 					if (!c.isEnabled())g.setColor(Color.LIGHT_GRAY);
 					else g.setColor(c.getForeground());
 					g.drawLine(x, y + 4, x + 4, y);
 					g.drawLine(x + 4, y, x + 8, y + 4);
 					g.drawLine(x + 4, y, x + 4, y + 8);
 				}
 			};
 		
 		case 2:
 			// plus icon
 			return new Icon(){
 				public int getIconHeight() {
 					return 10;
 				}
 				public int getIconWidth() {
 					return 10;
 				}
 				public void paintIcon(Component c, Graphics g, int x, int y) {
 					if (!c.isEnabled())g.setColor(Color.LIGHT_GRAY);
 					else g.setColor(c.getForeground());
 					g.drawLine(x, y + 4, x + 8, y + 4);
 					g.drawLine(x + 4, y, x + 4, y + 8);
 				}
 			};
 			
 		default:
 			// minus icon
 			return new Icon(){
 				public int getIconHeight() {
 					return 10;
 				}
 				public int getIconWidth() {
 					return 10;
 				}
 				public void paintIcon(Component c, Graphics g, int x, int y) {
 					if (!c.isEnabled())g.setColor(Color.LIGHT_GRAY);
 					else g.setColor(c.getForeground());
 					g.drawLine(x, y + 4, x + 8, y + 4);
 				}
 			};
 		}
 	}
 	
 	/**
 	 * Sets the forced dx. This dx will be used to multiply the original step
 	 * when performing zoom in/out and scale up/down.
 	 * 
 	 * @param forced new dx fraction
 	 */
 	public void setForcedDxFraction(double forced) {
 		if (this.forcedDx == forced) return;
 		double oldValue = this.forcedDx;
 		this.forcedDx = forced;
 		firePropertyChange("setForcedDxFraction",oldValue,forcedDx);
 	}
 	
 	/**
 	 * Returns the forced dx fraction.
 	 * 
 	 * @return forced dx fraction
 	 */
 	public double getForcedDxFraction() {
 		return forcedDx;
 	}
 }