/*
    * 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.AlphaComposite;
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.GradientPaint;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Insets;
  import java.awt.LayoutManager;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.event.MouseMotionListener;
  import java.awt.image.BufferedImage;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.swing.AbstractAction;
  import javax.swing.JButton;
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.JPanel;
  import javax.swing.TransferHandler;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.events.SetAdapter;
  import com.cosylab.events.SetEvent;
  import com.cosylab.events.SetListener;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.ledder.LedPaint;
  import com.cosylab.gui.components.ledder.LedPaintParameters;
  import com.cosylab.gui.components.range2.LinearRange;
  import com.cosylab.gui.components.range2.RangedValueController;
  import com.cosylab.gui.components.range2.RangedValueEvent;
  import com.cosylab.gui.components.range2.RangedValueListener;
  import com.cosylab.gui.components.range2.RangedValuePolicy;
  import com.cosylab.gui.components.range2.RescalingValuePolicy;
  import com.cosylab.gui.components.range2.Tick;
  import com.cosylab.gui.components.range2.TickParameters;
  import com.cosylab.gui.components.range2.TrimValuePolicy;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyTransferHandler;
  import com.cosylab.gui.components.util.FontHelper;
  import com.cosylab.gui.components.util.PaintHelper;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.cosylab.gui.components.util.ScreenCapturer;
  import com.cosylab.util.PrintfFormat;
  
  /**
   * A visual component for displaying and manipulating a double ranged value.
   * The value is set and displayed by a round dial knob GUI which can be
   * rotated by the user via mouse drag.
   *
   * @author Nejc Kosnik
   * @author Jernej Kamenik (<a
   *         href="mailto:jernej.kamenik@cosylab.com">jernej.kamenik&x40;cosylab.com</a>)
   * @version $id$
   */
  public class DialKnob extends JComponent implements PopupManageable,
  	StateOriginator, CosyTransferHandler.MouseFilter
  {
  	private static final long serialVersionUID = 1L;
  
  	/**
  	 * <code>ValueListener</code> handles events that occured due to externally 
  	 * made changes to the RangedValue. 
  	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $Id: DialKnob.java,v 1.38 2008-05-13 12:37:40 jbobnar Exp $
 	 * 
 	 * @since Feb 12, 2004.
 	 */
 	protected class ValueListener implements RangedValueListener {
 
 		/* (non-Javadoc)
 		 * @see com.cosylab.gui.components.range.RangedValueListener#valueChanged(com.cosylab.gui.components.range.RangedValueEvent)
 		 */
 		public void valueChanged(RangedValueEvent event) {
 			if (!isEnabled()) {
 				return;
 			}			
 			if (event.isMinOrMaxChanged()) {
 				renderer.clearScale();			
 			}
 
 			if (autoSynchronize) {
 				getAutoSyncTimer().restart();
 				lastValueTimestamp = System.currentTimeMillis();
 			}
 			
 			renderer.checkValue();
 			repaint();
 		}
 
 	}
 	/**
 	 * Utiliy class that handles user mouse actions on the Dial knob.
 	 *
 	 * @author Nejc Kosnik
 	 */
 	protected class MouseHandler extends MouseAdapter implements MouseListener, MouseMotionListener
 	{
 		private boolean inhibit;
 		private boolean isDragged = false;
 		private double angleBackground;
 		private double currentMouseAngle;
 		private double initMouseAngle;
 		private double initUserRelativeValue;
 
 		/**
 		 * Method which enables/disables setting of value via mouse drag.
 		 * Usually called when knob is to small to be painted and setting
 		 * value must also be disabled.
 		 *
 		 * @param newInhibit true to enable and false to disable user setting
 		 */
 		public void inhibit(boolean newInhibit)
 		{
 			inhibit = newInhibit;
 		}
 
 		/**
 		 * Does the value setting.
 		 *
 		 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
 		 */
 		public void mouseDragged(MouseEvent arg0)
 		{
 			if (inhibit || !isDragged) {
 				return;
 			}
 
 			//this prevents dragging outside of knob
 
 			/*
 			if (isMouseOutside(arg0)) {
 			    initMouseAngle = getMouseAngle(arg0);
 			    angleBackground = 0.0;
 			    return ;
 			}
 			*/
 			double mouseAngle = getMouseAngle(arg0);
 			double ratio = (rangedValue.getMaximum()-rangedValue.getMinimum())/(userRangedValue.getMaximum()-userRangedValue.getMinimum());
 			double valueToSet = initUserRelativeValue
 				+ (angleBackground + mouseAngle - initMouseAngle) / 1.5 / Math.PI * ratio;
 			valueToSet = (valueToSet > 1.0 ? 1.0
 				: (valueToSet < 0.0 ? 0.0 : valueToSet));
 
 			if (valueToSet == 0.0 || valueToSet == 1.0) {
 				mousePressed(arg0);
 			}
 			userRangedValue.setRelativeValue(valueToSet); /* edit apikus */
 		}
 
 		/**
 		 * Starts the value setting.
 		 *
 		 * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
 		 */
 		public void mousePressed(MouseEvent arg0)
 		{
 			if (isMouseOutside(arg0) || inhibit) {
 				return;
 			}
 
 			isDragged = true;
 			allowAutoSync = false;
 			
 			int relativeX = arg0.getX() - renderer.knobCenterX;
 			int relativeY = arg0.getY() - renderer.knobCenterY;
 			double tangens = (double)relativeY / relativeX;
 			currentMouseAngle = (relativeX >= 0.0
 				? Math.atan(tangens) + Math.PI / 2
 				: Math.atan(tangens) + 1.5 * Math.PI);
 			initMouseAngle = currentMouseAngle;
 			angleBackground = 0.0;
 			initUserRelativeValue = userRangedValue.getRelativeValue(); /* edit apikus */
 		}
 
 		/**
 		 * Finishes the value setting.
 		 *
 		 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
 		 */
 		public void mouseReleased(MouseEvent arg0)
 		{
 			isDragged = false;
 			if (arg0.getButton() == MouseEvent.BUTTON1 && autoSynchronize){
 				allowAutoSync = true;
 				lastValueTimestamp = System.currentTimeMillis();
 			}
 		}
 
 		//angle according to the center of the knob
 		private double getMouseAngle(MouseEvent arg0)
 		{
 			int relativeX = arg0.getX() - renderer.knobCenterX;
 			int relativeY = arg0.getY() - renderer.knobCenterY;
 			double tangens = (double)relativeY / relativeX;
 			double newAngle = (relativeX >= 0.0
 				? Math.atan(tangens) + Math.PI / 2
 				: Math.atan(tangens) + 1.5 * Math.PI);
 
 			if (Math.abs(newAngle - currentMouseAngle) > Math.PI) {
 				if (newAngle > currentMouseAngle) {
 					angleBackground -= 2 * Math.PI;
 				} else {
 					angleBackground += 2 * Math.PI;
 				}
 			}
 
 			currentMouseAngle = newAngle;
 
 			return currentMouseAngle;
 		}
 
 		//checks if mouse is out of allowable drag area
 		private boolean isMouseOutside(MouseEvent arg0)
 		{
 			int x = arg0.getX();
 			int y = arg0.getY();
 			int relativeX = x - renderer.knobCenterX;
 			int relativeY = y - renderer.knobCenterY;
 
 			if (relativeX * relativeX + relativeY * relativeY > renderer.knobDiameter * renderer.knobDiameter / 4.0) {
 				allowAutoSync = true;
 				lastValueTimestamp = System.currentTimeMillis();
 				return true;
 			}
 
 			return false;
 		}
 
 		public void mouseMoved(MouseEvent e) {
 			// TODO Auto-generated method stub
 			
 		}
 	}
 
 	/**
 	 * Utility class that rendering of the component
 	 *
 	 * @author Nejc Kosnik
 	 */
 	protected class Renderer implements TickParameters
 	{
 		//private TickParameters measurer;
 		private int knobCenterX;
 		private int knobCenterY;
 		private int knobDiameter;
 		private BufferedImage knobImage;
 		private BufferedImage markerImage;
 		private BufferedImage scaleImage;
 		private FontMetrics fontMetrics;
 		private Tick[] ticks;
 		private boolean checkedValue;
 		private boolean prohibitDrawing;
 		private int titleHeight;
 		private int fontHeight;
 		private int height;
 		private int markerImageSize;
 		private int scaleSize;
 		private int size;
 		private int width;
 
 		public void checkValue()
 		{
 			if (checkedValue != (userRangedValue.getValue() == labelValue)) {
 				checkedValue = (userRangedValue.getValue() == labelValue);
 				markerImage = null;
 			}
 		}
 
 		/**
 		 * Clears all buffered image resources, so they all have to be created
 		 * during the next repaint.
 		 */
 		public void clearBuffer()
 		{
 			knobImage = null;
 			scaleImage = null;
 			markerImage = null;
 		}
 
 		/**
 		 * Clears scale image, so it has to be reconstructed on the next
 		 * repaint. Typically called when scale range changes or when
 		 * component is resized.
 		 */
 		public void clearScale()
 		{
 			scaleImage = null;
 		}
 
 		/**
 		 * Gathers vital information about this component such as width,
 		 * height, font metrics and where to place the knob. Has to be called
 		 * before any painting methods to ensure proper rendering.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void initialize(Graphics2D g2d)
 		{
 			width = DialKnob.this.getWidth();
 			height = DialKnob.this.getHeight();
 			fontHeight = (resizable ? 5 + Math.min(width, height) / 25
 				: FontHelper.getDefaultFontSize());
 			g2d.setFont(FontHelper.getFontWithSize(fontHeight, g2d.getFont()));
 			fontMetrics = g2d.getFontMetrics();
 			titleHeight = (titleVisible && title!=null && title.length()>0 ? fontHeight * 12 / 10 : 0);
 			size = Math.min(width, height - titleHeight);
 
 			if (size <= 0) {
 				titleHeight = 0;
 				size = Math.min(width, height);
 			}
 
 			scaleSize = (size - 2 * fontHeight * 10 / 8);
 			knobDiameter = scaleSize * 8 / 10;
 
 			if (knobDiameter <= 0) {
 				prohibitDrawing = true;
 				if (isEditable())mouseHandler.inhibit(true);
 
 				return;
 			}
 
 			if (enhanced) {
 				g2d.addRenderingHints(PaintHelper.getAntialiasingHints());
 			}
 
 			knobCenterX = width / 2;
 			knobCenterY = height / 2 + titleHeight;
 			markerImageSize = Math.max(knobDiameter / 8, 10);
 			prohibitDrawing = false;
 			if (isEditable())getMouseHandler().inhibit(false);
 		}
 
 		/*
 		 * (non-Javadoc)
 		 * @see com.cosylab.gui.components.range2.TickParameters#measureTick(double, java.lang.String)
 		 */
 		public int measureTick(double position, String text)
 		{
 			return fontMetrics.stringWidth(text);
 		}
 
 		/**
 		 * Paints the Round shape representing the dial knob.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void paintKnob(Graphics2D g2d)
 		{
 			if (prohibitDrawing) {
 				return;
 			}
 
 			if (knobImage == null) {
 				knobImage = new BufferedImage(knobDiameter, knobDiameter,
 					    BufferedImage.TYPE_4BYTE_ABGR);
 
 				Graphics2D tmpG2d = knobImage.createGraphics();
 
 				if (enhanced) {
 					tmpG2d.addRenderingHints(PaintHelper.getAntialiasingHints());
 					tmpG2d.setPaint(new GradientPaint(0, 0, Color.WHITE,
 					        knobDiameter, knobDiameter,
 					        new Color(0.01f, 0, 0.3f)));
 					tmpG2d.fillOval(0, 0, knobDiameter, knobDiameter);
 				}
 
 				int edge = knobDiameter / 25;
 				tmpG2d.setColor(new Color(107, 109, 169));
 				tmpG2d.fillOval(edge, edge, knobDiameter - 2 * edge,
 				    knobDiameter - 2 * edge);
 			}
 
 			g2d.drawImage(knobImage, null, (width - knobDiameter) / 2,
 			    knobCenterY - knobDiameter / 2);
 		}
 
 		/**
 		 * Paints the marker of the DialKnob denoting the value set by the
 		 * user.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void paintMarker(Graphics2D g2d)
 		{
 			if (prohibitDrawing) {
 				return;
 			}
 
 			if (markerImageSize == 0) {
 				return;
 			}
 
 			int x = knobCenterX;
 			int y = knobCenterY;
 			int r = knobDiameter / 2 - markerImageSize;
 			float strokeWidth = Math.max(knobDiameter / 60.f, 3.f);
 			int r1 = knobDiameter / 2 + (int)strokeWidth / 2;
 			int r2 = knobDiameter / 2 * 17 / 15 - (int)strokeWidth / 2;
 
 			//double tempVal = (value>userRangedValue.getMaximum() ? userRangedValue.getMaximum() : value);
 			//tempVal = (tempVal<userRangedValue.getMinimum() ? userRangedValue.getMinimum() : tempVal);
 			double val = (rangedValue.getValue() - rangedValue.getMinimum()) / (rangedValue
 				.getMaximum() - rangedValue.getMinimum()); 
 			double angle = (val - 0.5) * Math.PI * 1.5;
 			boolean valueCheck = true;
 			if (labelValue>getGraphMax() || labelValue<getGraphMin()) valueCheck = false;
 			/*
 			 * The following selects the color of the marker needle.
 			 */
 			if(!rangeColors) {
 				markerColor = (valueCheck ? Color.GREEN : Color.YELLOW);
 			} else if(!valueCheck) {
 				if (labelValue < getGraphMin()) angle = angle-overLimitAngle;
 				else angle = angle+overLimitAngle;
 				markerColor = outOfBoundsColor;
 			} else if( (val <= lowAlarmLimit) || (val >= 1.0-highAlarmLimit) ){
 				markerColor = alarmColor;
 			} else if( (val <= lowWarningLimit) || (val >= 1.0-highWarningLimit) ){ 
 				markerColor = warningColor;
 			} else{
 				markerColor = normalColor;
 			}
 			g2d.setColor(markerColor);
 			
 			g2d.setStroke(new BasicStroke(strokeWidth));
 			g2d.drawLine((int)(x + r1 * Math.sin(angle)),
 			    (int)(y - r1 * Math.cos(angle)),
 			    (int)(x + r2 * Math.sin(angle)), (int)(y - r2 * Math.cos(angle)));
 
 			if (markerImage == null) {
 				markerImage = getMarkerImage();
 			}
 
 			//if (editable) {
 				val = userRangedValue.getValue();
 				if (val>rangedValue.getMaximum()) val = rangedValue.getMaximum();
 				if (val<rangedValue.getMinimum()) val = rangedValue.getMinimum();
 				val = (val - rangedValue.getMinimum()) / (rangedValue
 					.getMaximum() - rangedValue.getMinimum());  
 				angle = (val - 0.5) * Math.PI * 1.5;
 			//}
 
 			
 
 			g2d.drawImage(markerImage, null,
 			    (int)(x + r * Math.sin(angle) - markerImageSize / 2),
 			    (int)(y - r * Math.cos(angle) - markerImageSize / 2));
 
 			if (enhanced) {
 				g2d.setComposite(AlphaComposite.getInstance(
 				        AlphaComposite.SRC_ATOP, 0.5f));
 			}
 
 			if (editable) {
 				g2d.setColor(userRangedValue.getValue() == labelValue ? markerColor
 						: Color.RED);
 			} else {
 				g2d.setColor(Color.GRAY);
 			}
 
 			g2d.drawLine((int)(x + r1 * Math.sin(angle)),
 			    (int)(y - r1 * Math.cos(angle)),
 			    (int)(x + r2 * Math.sin(angle)), (int)(y - r2 * Math.cos(angle)));
 
 			//Restore original state of Graphics
 			if (enhanced) {
 				g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC));
 			}
 
 			g2d.setStroke(new BasicStroke());
 		}
 
 		/**
 		 * Paints the ticks of the DialKnob.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void paintTicks(Graphics2D g2d)
 		{
 			if (prohibitDrawing) {
 				return;
 			}
 
 			if (scaleImage == null) {
 				scaleImage = getScaleImage();
 			}
 
 			g2d.drawImage(scaleImage, null, knobCenterX - size / 2,
 			    knobCenterY - size / 2);
 		}
 
 		/**
 		 * Paints the title title on the top of the dial knob.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void paintTitleLabel(Graphics2D g2d)
 		{
 			if (titleHeight <= 0 || title == null || title.length()==0) {
 				return;
 			}
 
 //			g2d.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 			g2d.setColor((isEnabled() ? getForeground() : Color.GRAY));
 			g2d.drawString(title, (width - fontMetrics.stringWidth(title)) / 2,
 			    titleHeight);
 		}
 
 		/**
 		 * Paints the value title in the middle of the dial knob.
 		 *
 		 * @param g2d graphics representing this component
 		 */
 		public void paintValueLabel(Graphics2D g2d)
 		{
 			String text;
 			
 			try {
 				//text = formatter.sprintf(labelValue);
 				text = this.formatNumber(labelValue);
 			} catch (Exception e) {
 				text = Double.toString(labelValue);
 			}
 			
 			text += ((units == null || !unitsVisible) ? "" : " " + units);
 
 			if (fontMetrics.stringWidth(text) >= knobDiameter) {
 				return;
 			}
 
 //			g2d.setColor((isEnabled() ? Color.BLACK : Color.LIGHT_GRAY));
 			g2d.setColor((isEnabled() ? getForeground() : Color.LIGHT_GRAY));
 			g2d.drawString(text, (width - fontMetrics.stringWidth(text)) / 2,
 			    knobCenterY);
 		}
 
 		private BufferedImage getMarkerImage()
 		{
 			BufferedImage markerImage = new BufferedImage(markerImageSize,
 				    markerImageSize, BufferedImage.TYPE_4BYTE_ABGR);
 			Graphics2D tmpG2d = markerImage.createGraphics();
 
 			if (enhanced) {
 				tmpG2d.addRenderingHints(PaintHelper.getAntialiasingHints());
 			}
 
 			Color c = null;
 			if (editable) {
 				c = (userRangedValue.getValue() == labelValue? Color.GREEN : Color.RED);
 			} else {
 				c = Color.GRAY;
 			}
 			
 
 			if (enhanced) {
 				LedPaintParameters param = new LedPaintParameters();
 				param.lightX = -0.2;
 				param.lightY = -0.2;
 				param.shadowIntensity = 4;
 				param.radius = markerImageSize * 10 / 8;
 				param.borderSize = 0;
 				param.color = c;
 				tmpG2d.setPaint(new LedPaint(param,markerImageSize / 2,markerImageSize / 2));
 			} else {
 				tmpG2d.setColor(c);
 			}
 
 			tmpG2d.fillOval(0, 0, markerImageSize, markerImageSize);
 
 			return markerImage;
 		}
 
 		private BufferedImage getScaleImage()
 		{
 			BufferedImage image = new BufferedImage(size, size,
 				    BufferedImage.TYPE_4BYTE_ABGR);
 			Graphics2D g2d = image.createGraphics();
 
 			if (enhanced) {
 				g2d.addRenderingHints(PaintHelper.getAntialiasingHints());
 			}
 
 			int width = (scaleSize - knobDiameter) / 4;
 			int size0 = scaleSize - 4 * width;
 			g2d.setColor((tilting ? ColorHelper.getAlarm()
 			    : getBackground())); //ColorHelper.getCosyControl()));
 			g2d.setStroke(new BasicStroke(width));
 
 			int size1 = scaleSize - 3 * width;
 			g2d.drawOval((size - size1) / 2, (size - size1) / 2, size1, size1);
 
 			g2d.setStroke(new BasicStroke());
 			g2d.setColor(ColorHelper.getCosyControlShadow());
 
 			int size2 = scaleSize - 2 * width;
 			g2d.drawOval((size - size2) / 2, (size - size2) / 2, size2, size2);
 
 //			g2d.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 			g2d.setColor((isEnabled() ? getForeground() : Color.GRAY));
 			g2d.setFont(FontHelper.getFontWithSize(fontHeight, g2d.getFont()));
 			
 			//ticks = rangedValue.getRange().getTicks((int)(0.75 * Math.PI * (scaleSize - fontHeight))).toTicks(this);
 			ticks = rangedValue.calculateTicks((int)(0.75 * Math.PI * (scaleSize - fontHeight)),this);
 									
 			if (ticks == null) {
 				return image;
 			}
 
 			g2d.rotate(-Math.PI * 3 / 4, size / 2, size / 2);
 
 			double prop = 0.0;
 			if (getMinimum() > getMaximum()) return image;
 			for (int i = 0; i < ticks.length; i++) {
 				g2d.rotate((ticks[i].proportional - prop) * Math.PI * 3 / 2,
 				    size / 2, size / 2);
 				prop = ticks[i].proportional;
 
 				if (ticks[i].major) { //major tick
 					g2d.drawLine(size / 2, (size - size0) / 2, size / 2,
 					    (size - size2) / 2 + 1);
 
 					String text = ticks[i].text;
 
 					if (text != null) {
 						g2d.drawString(text,
 						    (size - fontMetrics.stringWidth(text)) / 2,
 						    (size - size2) / 2 - 5);
 					}
 				} else { //minor tick
 					g2d.drawLine(size / 2, (size - size0) / 2, size / 2,
 					    (size - size2) / 4 + (size - size0) / 4 + 1);
 				}
 			}
 
 			return image;
 		}
 		
 		/*
 		 * (non-Javadoc)
 		 * @see com.cosylab.gui.components.range2.TickParameters#formatNumber(double)
 		 */
 		public String formatNumber(double x) { 
 			return formatter.sprintf(x);
 		}
 	}
 
 	private class ResizeListener extends ComponentAdapter
 	{
 		/*
 		 * (non-Javadoc)
 		 * @see java.awt.event.ComponentAdapter#componentResized(java.awt.event.ComponentEvent)
 		 */
 		public void componentResized(ComponentEvent cEvent)
 		{
 			renderer.clearBuffer();
 			repaint();
 		}
 	}
 
 	/**
 	 * An extension of Timer used for periodic tilting of the Dial Knob.
 	 *
 	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
 	 * @version $id$
 	 *
 	 */
 	protected class TiltHandler extends Timer
 	{
 		private class TiltTask extends TimerTask
 		{
 			/**
 			 * DOCUMENT ME!
 			 */
 			public void run()
 			{
 				if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 					cancel();
 					tilting = false;
 				} else {
 					numberOfTilts++;
 					tilting = !tilting;
 				}
 
 				renderer.clearScale();
 				repaint();
 			}
 		}
 
 		private final int MAX_NUMBER_OF_TILTS = 3;
 		private final long TILT_RATE = 200;
 		private int numberOfTilts = MAX_NUMBER_OF_TILTS;
 
 		/**
 		 * Scedules a new tilting task if the user value equals any of the
 		 * bounds.
 		 */
 		public void tilt()
 		{
 			if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 				numberOfTilts = 0;
 				schedule(new TiltTask(), 0, TILT_RATE);
 			} else {
 				numberOfTilts = 0;
 			}
 		}
 	}
 
 	/**
 	 * Listens for changes in uservalue.
 	 *
 	 * @author Nejc Kosnik
 	 */
 	protected class UserValueListener implements RangedValueListener
 	{
 		/*
 		 * (non-Javadoc)
 		 * @see com.cosylab.gui.components.range2.RangedValueListener#valueChanged(com.cosylab.gui.components.range2.RangedValueEvent)
 		 */
 		public void valueChanged(RangedValueEvent rvEvent)
 		{
 			if (rvEvent.isValueChanged()) {
 				/*
 				 * Fix for out of bounds behaviour of this component (RT #26250).
 				 * Replaced:
 				 * notifyListeners(userRangedValue.getValue());
 				 */
 				notifyListeners(userRangedValue.getRawValue());
 			}
 			if (autoSynchronize) {
 				getAutoSyncTimer().stop();
 				lastValueTimestamp = System.currentTimeMillis();
 			}
 
 			//			if (rvEvent.minMaxChanged())
 			//				renderer.clearScale();
 			renderer.checkValue();
 			
 			if (!isEnabled()) {
 				return;
 			}
 			
 			DialKnob.this.repaint();
 		}
 	}
 
 	private JButton syncButton;
 	private RangedValuePolicy policy;
 	protected MouseHandler mouseHandler;
 	protected PrintfFormat formatter;
 	protected RangedValueController userRangedValue;
 	protected Renderer renderer;
 	protected String format;
 	protected String title;
 	protected String units;
 	protected boolean titleVisible;
 	protected RangedValueController rangedValue;
 	private AbstractCustomizerPanel customizer;
 	private PopupManager popupManager;
 	private TiltHandler tiltHandler;
 	private boolean editable;
 	private boolean enhanced = true;
 	private boolean painting;
 	private boolean popupEnabled;
 	private boolean resizable = true;
 	private boolean tilting;
 	private boolean tiltingEnabled;
 	private double labelValue;
 	private boolean unitsVisible = true;
 	
 	/* 
 	 * Selects if marker needle color should change with respect to its 
 	 * position on the scale. 
 	 */
 	private boolean rangeColors = true;
 	
 	/* Range boundaries. */
 	private double lowAlarmLimit = 0.05;
 	private double lowWarningLimit= 0.2;
 	private double highWarningLimit= 0.2;
 	private double highAlarmLimit= 0.05;
 	
 	/* Colors. */
 	private Color normalColor = new Color(0, 192, 0);
 	private Color alarmColor = new Color(239,0,0);
 	private Color warningColor = new Color(0xEEEC300);
 	private Color outOfBoundsColor = new Color(239,0,0);
 	/* 
 	 * Angle that is added to maximum deflection of the marker when value 
 	 * is out ob bounds.
 	 */
 	private double overLimitAngle = 5.0 / 180 * Math.PI;
 	/* Current color of the marker. */
 	private Color markerColor = null;
 	
 	/* 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;
 	long lastValueTimestamp = System.currentTimeMillis();
 	
 	/**
 	 * Creates a new DialKnob object with null title and 0 values.
 	 */
 	public DialKnob()
 	{
 		this(null, 0, 0);
 	}
 
 	/**
 	 * Constructs a new DialKnob object with the given title of the widget.
 	 *
 	 * @param newLabel title of the widget
 	 */
 	public DialKnob(String newLabel)
 	{
 		this(newLabel, -20, -20);
 	}
 
 	/**
 	 * Constructs DialKnob with the given title and given user and readback values.
 	 *
 	 * @param newLabel title of the widget
 	 * @param newUserValue user value
 	 * @param newValue readback value (shadow)
 	 */
 	public DialKnob(String newLabel, double newUserValue, double newValue)
 	{
 		super();
 
 		title = newLabel;
 
 		format = "%3.2f";
 		formatter = new PrintfFormat(format);
 
 		renderer = new Renderer();
 
 		userRangedValue = new RangedValueController(); /* edit apikus */
 		userRangedValue.setRange(new LinearRange()); /* edit apikus */
 		
 		labelValue = newValue;
 
 		if (newUserValue == 0) {
 			userRangedValue.setValue(0, 1, 0);
 		} else {
 			userRangedValue.setValue(newUserValue - Math.abs(newUserValue),
 			    newUserValue + 3 * Math.abs(newUserValue), newUserValue);
 		}
 
 		userRangedValue.addPolicy(new TrimValuePolicy());
 		userRangedValue.addRangedValueListener(new UserValueListener());
 				
 		addComponentListener(new ResizeListener());
 		
 		rangedValue = new RangedValueController();
 		rangedValue.setRange(new LinearRange());
 
 		if (newValue == 0) {
 			rangedValue.setValue(0, 1, 0);
 		} else {
 			rangedValue.setValue(newValue - Math.abs(newValue),
 				newValue + 3 * Math.abs(newValue), newValue);
 		}
 
 		policy = new RescalingValuePolicy();
 		rangedValue.addPolicy(policy);
 		rangedValue.addRangedValueListener(new ValueListener());
 
 		
 		setLayout(new LayoutManager() {
 			public void removeLayoutComponent(Component comp) {
 			}
 
 			public void layoutContainer(Container parent) {
 				Dimension size = getSyncButton().getPreferredSize();
 				int x = getWidth()-size.width-getInsets().right-2;
 				int y = getInsets().top+2;
 				getSyncButton().setBounds(x,y,size.width,size.height);
 			}
 
 			public void addLayoutComponent(String name, Component comp) {
 			}
 
 			public Dimension minimumLayoutSize(Container parent) {
 				return null;
 			}
 
 			public Dimension preferredLayoutSize(Container parent) {
 				return null;
 			}
 		});
 		//setLayout(new GridBagLayout());
 		//GridBagConstraints c = new GridBagConstraints(0,0,1,1,0,0,GridBagConstraints.NORTHEAST,GridBagConstraints.NONE,new Insets(2,2,2,2),0,0);
 		add(getSyncButton());
 
 		setBackground(ColorHelper.getCosyControl());
 		setPreferredSize(new Dimension(200, 200));
 		setMinimumSize(new Dimension(85, 85));
 		setOpaque(true);
 		setVisible(true);
 		setPopupEnabled(true);
 	}
 	
 	private JButton getSyncButton() {
 		if (syncButton == null) {
 			syncButton = new JButton("Sync");
 			syncButton.setOpaque(false);
 			syncButton.setMargin(new Insets(0, 1, 0, 1));
 			syncButton.setFont(new Font(syncButton.getFont().getName(), Font.PLAIN, 9));
 			syncButton.addActionListener(new ActionListener() {
 				public void actionPerformed(ActionEvent e) {
 					synchronize();
 				}
 			});
 			
 		}
 
 		return syncButton;
 	}
 
 	/**
 	 * Loads and returns the default <code>Customizer</code> for this displayer.
 	 *
 	 * @return the Customizer intance for this displayer
 	 * @see com.cosylab.gui.components.customizer.Customizer
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 
 		return customizer;
 	}
 
 	/**
 	 * Sets the enhanced rendering of the widget. If property is true
 	 * there will be much more attention payed to the visual details when 
 	 * rendering of the displayer occurs. Such rendering might cost
 	 * more CPU time. By default enhanced rendering is on. 
 	 *
 	 * @param b
 	 */
 	public void setEnhanced(boolean b)
 	{
 		if (enhanced == b) {
 			return;
 		}
 
 		enhanced = b;
 		renderer.clearBuffer();
 		repaint();
 		firePropertyChange("enhanced", !b, b);
 	}
 
 	/**
 	 * Returns whether the component should be rendered enhanced.
 	 *
 	 * @return enhanced
 	 */
 	public boolean isEnhanced()
 	{
 		return enhanced;
 	}
 
 	/**
 	 * Sets the C-style number display format string.
 	 *
 	 * @param newFormat C-style format string.
 	 */
 	public void setFormat(String newFormat)
 	{
 		String oldFormat = format;
 		format = newFormat;
 		formatter = new PrintfFormat(format);
 		firePropertyChange("format", oldFormat, newFormat);
 		renderer.clearBuffer();
 		if (!isEnabled()) {
 			return;
 		}
 		
 		repaint();
 	}
 
 	/**
 	 * Gets the C-style number display format string.
 	 *
 	 * @return String
 	 */
 	public String getFormat()
 	{
 		return format;
 	}
 
 	/**
 	 * Sets the maximum value the user can set.
 	 *
 	 * @param newMax maximum value the user can set.
 	 */
 	public void setUserMax(double newMax)
 	{
 
 		double oldMax = userRangedValue.getMaximum(); /* edit apikus */
 		userRangedValue.setMaximum(newMax); /* edit apikus */
 						
 		firePropertyChange("userMax", oldMax, newMax);
 		if (newMax<rangedValue.getMaximum()) setGraphMax(newMax);
 	}
 
 	/**
 	 * Sets the maximum value displayed.
 	 *
 	 * @param newMax maximum for the knob scale
 	 */
 	public void setGraphMax(double newMax)
 	{
 		double oldMax = rangedValue.getMaximum();
 		rangedValue.setValue(rangedValue.getMinimum(), newMax,rangedValue.getValue());
 		firePropertyChange("graphMax", oldMax, newMax);
 	}
 
 	/**
 	 * Sets all max values for this widget. This method will set the max
 	 * value a user can set as well as the max displayed value.
 	 * 
 	 * @param value new maximum value
 	 * @see #setUserMax(double)
 	 * @see #setGraphMax(double)
 	 */
 	public void setMaximum(double value) {
 		double old = getMaximum();
 		setUserMax(value);
 		setGraphMax(value);
 		firePropertyChange("maximum",old,value);
 	}
 
 	/**
 	 * Returns the maximum value the user can set.
 	 *
 	 * @return double upper bound value the user can set.
 	 */
 	public double getUserMax()
 	{
 		return userRangedValue.getMaximum(); /* edit apikus */
 	}
 
 	/**
 	 * A convenience method returns the user maximum value
 	 *
 	 * @return double upper bound value the user can set.
 	 */
 	public double getMaximum()
 	{
 		return getUserMax();
 	}
 	/**
 	 * Gets the maximum value displayed.
 	 *
 	 * @return double upper bound value for knob scale
 	 */
 	public double getGraphMax()
 	{
 		return rangedValue.getMaximum(); /* edit apikus */
 	}
 
 
 	/**
 	 * Sets the minimum value the user can set.
 	 *
 	 * @param newMin minimum value the user can set.
 	 */
 	public void setUserMin(double newMin)
 	{
 		double oldMin = userRangedValue.getMinimum(); /* edit apikus */
 		userRangedValue.setMinimum(newMin);
 		
 		firePropertyChange("userMin", oldMin, newMin);
 		if (newMin<rangedValue.getMinimum()) setGraphMin(newMin);
 	}
 
 	/**
 	 * Sets the minimum value displayed.
 	 *
 	 * @param newMin minimum for the knob scale
 	 */
 	public void setGraphMin(double newMin)
 	{
 		double oldMin = rangedValue.getMinimum();
 		rangedValue.setValue(newMin, rangedValue.getMaximum(),rangedValue.getValue());
 		firePropertyChange("graphMin", oldMin, newMin);
 	}
 
 	/**
 	 * Sets all min values for this widget. This method will set the min
 	 * value a user can set as well as the min displayed value.
 	 * 
 	 * @param value new minimum value
 	 * @see #setUserMin(double)
 	 * @see #setGraphMin(double)
 	 */
 	public void setMinimum(double value) {
 		double oldValue = getMinimum();
 		setGraphMin(value);
 		setUserMin(value);
 		firePropertyChange("minimum", oldValue, value);
 	}
 	
 	/**
 	 * Convenience method returns the minimum user value.
 	 *
 	 * @return double lower bound value the user can set
 	 */
 	public double getMinimum()
 	{
 		return getUserMin();
 	}
 
 	/**
 	 * Returns the minimum value the user can set.
 	 * @return user minimum
 	 */
 	public double getUserMin() {
 		return userRangedValue.getMinimum(); /* edit apikus */
 	}
 
 	/**
 	 * Returns the minimum value displayed.
 	 *
 	 * @return double lower bound value for knob scale
 	 */
 	public double getGraphMin() {
 		return rangedValue.getMinimum(); /* edit apikus */
 	}
 	
 	/**
 	 * Returns whether the user can trigger the component's popup menu through a
 	 * mouse click.
 	 *
 	 * @return true if popup is enabled
 	 */
 	public boolean isPopupEnabled()
 	{
 		return popupEnabled;
 	}
 
 	/**
 	 * Returns the popup manager employed by this widget. Default values in the
 	 * popup menu are <code>Synchronize</code>, <code>Preferences...</code>, and
 	 * <code>Capture Screen...</code>.
 	 * @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(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 
 				public void actionPerformed(ActionEvent e)
 				{
 					getCustomizer().showDialog();
 				}
 			});
 			popupManager.addAction(new AbstractAction("Capture Screen...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{	ScreenCapturer sc = new ScreenCapturer(DialKnob.this);
 						sc.showScreenDialog();
 					}
 					
 				});
 		}
 
 		return popupManager;
 	}
 
 	/**
 	 * Enables/disables text adjusting.
 	 *
 	 * @param b whether the text should adjust its side to the size of the
 	 *        component.
 	 */
 	public void setResizable(boolean b)
 	{
 		if (b == resizable) {
 			return;
 		}
 
 		resizable = b;
 
 		renderer.clearBuffer();
 		repaint();
 		firePropertyChange("resizable", !b, b);
 	}
 
 	/**
 	 * Returns true if the component's text adjusts to the size of the component.
 	 *
 	 * @return resizable property.
 	 */
 	public boolean isResizable()
 	{
 		return resizable;
 	}
 
 	/**
 	 * Sets the state to the component.
 	 *
 	 * @param state to set.
 	 *
 	 * @see com.cosylab.application.state.StateOriginator#setState(com.cosylab.application.state.State)
 	 */
 	public void setState(State state)
 	{
 		setFormat(state.getString("format", getFormat()));
 		setMaximum(state.getDouble("maximum", getMaximum()));
 		setMinimum(state.getDouble("minimum", getMinimum()));
 		setTitle(state.getString("title", getTitle()));
 		setUnits(state.getString("units", getUnits()));
 		setTitleVisible(state.getBoolean("titleVisible", isTitleVisible()));
 		setEnhanced(state.getBoolean("enhanced", isEnhanced()));
 		setResizable(state.getBoolean("resizable", isResizable()));
 		setTiltingEnabled(state.getBoolean("tiltingEnabled", isTiltingEnabled()));
 	}
 
 	/**
 	 * Returns the current state of the component.
 	 *
 	 * @return current state.
 	 *
 	 * @see com.cosylab.application.state.StateOriginator#getState()
 	 */
 	public State getState()
 	{
 		State state = StateFactory.createState();
 
 		state.putString("format", getFormat());
 		state.putDouble("maximum", getMaximum());
 		state.putDouble("minimum", getMinimum());
 		state.putString("title", getTitle());
 		state.putString("units", getUnits());
 		state.putBoolean("titleVisible", isTitleVisible());
 		state.putBoolean("enhanced", isEnhanced());
 		state.putBoolean("resizable", isResizable());
 		state.putBoolean("tiltingEnabled", isTiltingEnabled());
 
 		return state;
 	}
 
 	/**
 	 * Sets the title above the knob.
 	 *
 	 * @param string new title
 	 */
 	public void setTitle(String string)
 	{
 		String oldTitle = title;
 		title = string;
 		firePropertyChange("title", oldTitle, string);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Returns the title of the widget.
 	 *
 	 * @return Title
 	 */
 	public String getTitle()
 	{
 		return title;
 	}
 
 	/**
 	 * Toggles title's visibility.
 	 *
 	 * @param b visibility of the title
 	 */
 	public void setTitleVisible(boolean b)
 	{
 		if (titleVisible == b) return;
 		boolean oldB = titleVisible;
 		titleVisible = b;
 		firePropertyChange("titleVisible", oldB, b);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Returns true if title is visible.
 	 *
 	 * @return titleVisible visibility of the title
 	 */
 	public boolean isTitleVisible()
 	{
 		return titleVisible;
 	}
 
 	/**
 	 * Sets the displayed units.
 	 *
 	 * @param newUnit units to be displayed on the value title
 	 */
 	public void setUnits(String newUnit)
 	{
 		String oldUnits = units;
 		units = newUnit;
 		firePropertyChange("units", oldUnits, newUnit);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Returns the displayed units.
 	 *
 	 * @return String current units shown on the value title
 	 */
 	public String getUnits()
 	{
 		return units;
 	}
 
 	/**
 	 * Sets the user value.
 	 *
 	 * @param newUserValue new value.
 	 */
 	public void setUserValue(double newUserValue)
 	{
 		double oldUserValue = userRangedValue.getValue();
 
 		userRangedValue.setValue(newUserValue);
 		renderer.checkValue();
 		firePropertyChange("userValue", oldUserValue, getUserValue());
 
 		if (autoSynchronize) {
 			getAutoSyncTimer().stop();
 			lastValueTimestamp = System.currentTimeMillis();
 		}
 		
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Return the value as set by the user.
 	 *
 	 * @return double user value setting
 	 */
 	public double getUserValue()
 	{
 		return userRangedValue.getValue();
 	}
 
 	/**
 	 * Sets the value displayed
 	 *
 	 * @param newValue value to be displayed on the title marker
 	 */
 	public void setValue(double newValue)
 	{
 //		double oldValue = rangedValue.getValue();
 		double oldValue = getValue();
 
 		if (oldValue == newValue) {
 			return;
 		}
 		
 		labelValue = newValue;
 		renderer.checkValue();
 
 		rangedValue.setValue(newValue);
 		
 
 		if (autoSynchronize) {
 			if (oldValue != newValue) {
 				getAutoSyncTimer().restart();
 			} else {
 				if (!getAutoSyncTimer().isRunning()) {
 					getAutoSyncTimer().start();
 				}
 			}
 		
 		} 
 		
 		firePropertyChange("value", oldValue, getValue());
 
 		if ((newValue > userRangedValue.getMaximum()
 		    || newValue < userRangedValue.getMinimum()) && tiltingEnabled) {
 			getTiltHandler().tilt();
 		}
 
 	}
 
 	/**
 	 * Returns the displayed value.
 	 *
 	 * @return double value displayed on the title marker
 	 */
 	public double getValue()
 	{
 		return labelValue;
 	}
 
 	/**
 	 * Adds a listener which receive event notifications when the user 
 	 * sets a new value.
 	 *
 	 * @param listener listener to be added
 	 */
 	public void addSetListener(SetListener listener)
 	{
 		listenerList.add(SetListener.class, listener);
 	}
 
 	/**
 	 * Sets the editable property. If editable, the user can change the user
 	 * value by mouse dragg.
 	 *
 	 * @param b editable
 	 */
 	public void setEditable(boolean b)
 	{
 		if (editable == b) {
 			return;
 		}
 
 		editable = b;
 
 		if (b) {
 			addMouseListener(getMouseHandler());
 			addMouseMotionListener(getMouseHandler());
 		} else {
 			removeMouseListener(getMouseHandler());
 			removeMouseMotionListener(getMouseHandler());
 		}
 
 		firePropertyChange("editable", !b, b);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		renderer.markerImage=null;
 		repaint();
 	}
 
 	/**
 	 * Returns whether the value can be edited by user.
 	 *
 	 * @return editable
 	 */
 	public boolean isEditable()
 	{
 		return editable;
 	}
 
 	/**
 	 * Overriden to implement visual notification of enabled state.
 	 *
 	 * @see java.awt.Component#setEnabled(boolean)
 	 */
 	public void setEnabled(boolean enabled)
 	{
 		super.setEnabled(enabled);
 
 		renderer.clearBuffer();
 		repaint();
 	}
 
 	/**
 	 * 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 (popupEnabled != b) {
 			if (b) {
 				addMouseListener(getPopupManager().getMouseHook());
 			} else {
 				removeMouseListener(getPopupManager().getMouseHook());
 			}
 		}
 
 		popupEnabled = b;
 		firePropertyChange("popupEnabled", !b, b);
 	}
 
 	/**
 	 * Enables/disables the tilting. Component tilts when value is out of
 	 * bounds.
 	 *
 	 * @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;
 	}
 
 	/**
 	 * Removes a listener from the list of listeners receiving event
 	 * notifications when the user sets a new value.
 	 *
 	 * @param listener listener to remove
 	 */
 	public void removeSetListener(SetListener listener)
 	{
 		listenerList.remove(SetListener.class, listener);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.Component#repaint()
 	 */
 	public void repaint()
 	{
 		if (painting) {
 			return;
 		}
 
 		super.repaint();
 	}
 
 	/**
 	 * Synchronizes the user value with the value;
 	 */
 	public void synchronize()
 	{
 		setUserValue(getValue());
 	}
 
 	/**
 	 * Notifies all the listeners attached to user value.
 	 *
 	 * @param newValue new user value
 	 */
 	protected void notifyListeners(double newValue)
 	{
 		SetEvent e = new SetEvent(this, newValue);
 		SetListener[] list = listenerList.getListeners(SetListener.class);
 
 		for (int i = 0; i < list.length; i++) {
 			list[i].setPerformed(e);
 		}
 	}
 
 	/**
 	 * Paints the Dial Knob component by utilizing the Renderer. The GUI
 	 * comprises of a round shape with a value title in the middle, a title on
 	 * the top and value tick marks around approximately upper two thirds of
 	 * the circle.
 	 *
 	 * @param arg0 Graphics of the DialKnob component.
 	 *
 	 * @see com.cosylab.gui.components.range.Tick
 	 * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
 	 */
 	protected void paintComponent(Graphics arg0)
 	{
 		if (painting) {
 			return;
 		}
 
 		painting = true;
 
 		arg0.setColor(getBackground());
 		arg0.fillRect(0, 0, getWidth(), getHeight());
 
 		Graphics2D g2d = (Graphics2D)arg0;
 		renderer.initialize(g2d);
 		renderer.paintTicks(g2d);
 		renderer.paintKnob(g2d);
 		renderer.paintMarker(g2d);
 		renderer.paintTitleLabel(g2d);
 		renderer.paintValueLabel(g2d);
 
 		painting = false;
 	
 	}
 
 	private MouseHandler getMouseHandler()
 	{
 		if (mouseHandler == null) {
 			mouseHandler = new MouseHandler();
 		}
 
 		return mouseHandler;
 	}
 
 	private TiltHandler getTiltHandler()
 	{
 		if (tiltHandler == null) {
 			tiltHandler = new TiltHandler();
 		}
 
 		return tiltHandler;
 	}
 	
 	/**
 	 * Sets the ValuePolicy.
 	 * 
 	 * @param p new value policy
 	 */
 	public void setValuePolicy(RangedValuePolicy p) {
 		RangedValuePolicy oldValue = getValuePolicy();
 		rangedValue.removePolicy(policy);
 		this.policy = p;
 		rangedValue.addPolicy(p);
 		firePropertyChange("valuePolicy", oldValue, p);
 	}
 
 	/**
 	 * Returns the value policy.
 	 * 
 	 * @return
 	 */
 	public RangedValuePolicy getValuePolicy() {
 		return policy;
 	}
 	
 	/**
 	 * Returns the main ranged value.
 	 * 
 	 * @return
 	 */
 	protected RangedValueController getRangedValue() {
 		return rangedValue;
 	}
 
 	/**
 	 * Returns the user ranged value.
 	 * 
 	 * @return
 	 */
 	protected RangedValueController getUserRangedValue() {
 		return userRangedValue;
 	}
 
 	/**
 	 * Returns true if units are visible.
 	 * 
 	 * @return units visibile
 	 */
 	public boolean isUnitsVisible() {
 		return unitsVisible;
 	}
 
 	/**
 	 * Sets the units visible/invisible.
 	 * 
 	 * @param b units visible
 	 */
 	public void setUnitsVisible(boolean b) {
 		if (unitsVisible==b) return;
 		boolean oldB = unitsVisible;
 		unitsVisible = b;
 		firePropertyChange("unitsVisible",oldB,b);
 		repaint();
 	}
 
 	/**
 	 * Returns the color which indicates the alarm state.
 	 * 
 	 * @return Returns the alarmColor.
 	 */
 	public Color getAlarmColor() {
 		return alarmColor;
 	}
 
 	/**
 	 * Sets the color which indicates the alarm state.
 	 * 
 	 * @param alarmColor The alarmColor to set.
 	 */
 	public void setAlarmColor(Color alarmColor) {
 		Color oldValue = getAlarmColor();
 		this.alarmColor = alarmColor;
 		firePropertyChange("alarmColor", oldValue, alarmColor);
 	}
 
 	/**
 	 * Returns the high alarm limit.
 	 * 
 	 * @return Returns the highAlarmLimit.
 	 */
 	public double getHighAlarmLimit() {
 		return highAlarmLimit;
 	}
 
 	/**
 	 * Sets the high alarm limit.
 	 * 
 	 * @param highAlarmLimit new high alarm limit
 	 */
 	public void setHighAlarmLimit(double highAlarmLimit) {
 		double oldValue = getHighAlarmLimit();
 		this.highAlarmLimit = highAlarmLimit;
 		firePropertyChange("highAlarmLimir", oldValue, this.highAlarmLimit);
 	}
 
 	/**
 	 * Returns the high warning limit.
 	 * 
 	 * @return Returns the highWarningLimit.
 	 */
 	public double getHighWarningLimit() {
 		return highWarningLimit;
 	}
 
 	/**
 	 * Sets the high warning limit.
 	 * 
 	 * @param highWarningLimit new high warning limit
 	 */
 	public void setHighWarningLimit(double highWarningLimit) {
 		double oldValue = getHighWarningLimit();
 		this.highWarningLimit = highWarningLimit;
 		firePropertyChange("highWarningLimit", oldValue, this.highWarningLimit);
 	}
 
 	/**
 	 * Returns the low alarm limit.
 	 * 
 	 * @return Returns the lowAlarmLimit.
 	 */
 	public double getLowAlarmLimit() {
 		return lowAlarmLimit;
 	}
 
 	/**
 	 * Sets the low alarm limit.
 	 * 
 	 * @param lowAlarmLimit new low alarm limit
 	 */
 	public void setLowAlarmLimit(double lowAlarmLimit) {
 		double oldValue = getLowAlarmLimit();
 		this.lowAlarmLimit = lowAlarmLimit;
 		firePropertyChange("lowAlarmLimit", oldValue, this.lowAlarmLimit);
 	}
 
 	/**
 	 * Returns the low warning limit.
 	 * 
 	 * @return Returns the lowWarningLimit.
 	 */
 	public double getLowWarningLimit() {
 		return lowWarningLimit;
 	}
 
 	/**
 	 * Sets the low warning limit.
 	 * 
 	 * @param lowWarningLimit new low warning limit
 	 */
 	public void setLowWarningLimit(double lowWarningLimit) {
 		double oldValue = getLowWarningLimit();
 		this.lowWarningLimit = lowWarningLimit;
 		firePropertyChange("lowWarningLimit", oldValue, this.lowWarningLimit);
 	}
 
 	/**
 	 * Returns the color which indicates the normal state.
 	 * 
 	 * @return Returns the normalColor.
 	 */
 	public Color getNormalColor() {
 		return normalColor;
 	}
 
 	/**
 	 * Sets the color which indicates the normal state.
 	 * 
 	 * @param normalColor new normal color
 	 */
 	public void setNormalColor(Color normalColor) {
 		Color oldValue = getNormalColor();
 		this.normalColor = normalColor;
 		firePropertyChange("normalColor", oldValue, this.normalColor);
 	}
 
 	/**
 	 * Returns the color that indicates out of bound state.
 	 * 
 	 * @return Returns the outOfBoundsColor.
 	 */
 	public Color getOutOfBoundsColor() {
 		return outOfBoundsColor;
 	}
 
 	/**
 	 * Sets the color that indicates out of bound state.
 	 * 
 	 * @param outOfBoundsColor new out of bounds color
 	 */
 	public void setOutOfBoundsColor(Color outOfBoundsColor) {
 		Color oldValue = getOutOfBoundsColor();
 		this.outOfBoundsColor = outOfBoundsColor;
 		firePropertyChange("outOfBoundsColor", oldValue, this.outOfBoundsColor);
 	}
 
 	/**
 	 * Returns true if marker is colored when out of range.
 	 * 
 	 * @return Returns the rangeColors.
 	 */
 	public boolean isRangeColors() {
 		return rangeColors;
 	}
 
 	/**
 	 * Set whether the value marker is colored when out of range.
 	 * 
 	 * @param rangeColors color value marker
 	 */
 	public void setRangeColors(boolean rangeColors) {
 		this.rangeColors = rangeColors;
 	}
 
 	/**
 	 * Returns the warning color.
 	 * 
 	 * @return Returns the warningColor.
 	 */
 	public Color getWarningColor() {
 		return warningColor;
 	}
 
 	/**
 	 * Sets the color which idicates warning state.
 	 * 
 	 * @param warningColor The warningColor to set.
 	 */
 	public void setWarningColor(Color warningColor) {
 		Color oldValue = getWarningColor();
 		this.warningColor = warningColor;
 		firePropertyChange("warningColor", oldValue, warningColor);
 	}
 	
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.util.CosyTransferHandler.MouseFilter#isDragArea(java.awt.event.MouseEvent)
 	 */
 	public boolean isDragArea(MouseEvent e) {
 		return getMouseHandler().isMouseOutside(e);
 	}
 	
 	/* (non-Javadoc)
 	 * @see javax.swing.JComponent#setTransferHandler(javax.swing.TransferHandler)
 	 */
 	@Override
 	public void setTransferHandler(TransferHandler newHandler) {
 		super.setTransferHandler(newHandler);
 		if (newHandler instanceof CosyTransferHandler) {
 			CosyTransferHandler t = (CosyTransferHandler) newHandler;
 			t.addMouseFilter(this);
 			
 		}
 	}
 	
 	/**
 	 * 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();
 		} else {
 			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();
 		} else {
 			return getTransferHandler() != null;
 		}
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setBackground(java.awt.Color)
 	 */
 	@Override
 	public void setBackground(Color bg) {
 		super.setBackground(bg);
 		getSyncButton().setBackground(bg);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setForeground(java.awt.Color)
 	 */
 	@Override
 	public void setForeground(Color fg) {
 		super.setForeground(fg);
 		getSyncButton().setForeground(fg);
 	}
 		
 	/**
 	 * Returns true if auto synchronization is turn on.
 	 * 
 	 * @return
 	 */
 	public boolean isAutoSynchronize() {
 		return autoSynchronize;
 	}
 
 	/**
 	 * Turns the autoSynchronization on/off. When auto synchronization is
 	 * on, the knob will automatically synchronize with the readback value if
 	 * inactive for more than specified by auto sycnhronbize delay.
 	 * 
 	 * 
 	 * @param autoSynchronize
 	 * @see #setAutoSynchronizeDelay(long)
 	 */
 	public void setAutoSynchronize(boolean autoSynchronize) {
 		if(isAutoSynchronize() == autoSynchronize) return;
 		this.autoSynchronize = autoSynchronize;
 		allowAutoSync = true;
 		if (autoSynchronize) {
 			getAutoSyncTimer().restart();
 		} else {
 			getAutoSyncTimer().stop();
 		}
 		firePropertyChange("autoSynchronize", !autoSynchronize, autoSynchronize);
 	}
 	
 	private javax.swing.Timer autoSyncTimer;
 	private javax.swing.Timer getAutoSyncTimer() {
 		if (autoSyncTimer == null) {
 			autoSyncTimer = new javax.swing.Timer((int)autoSynchronizeDelay, new ActionListener(){
 				public void actionPerformed(ActionEvent e) {
 					if (allowAutoSync)
 						synchronize();
 					autoSyncTimer.stop();
 				}
 			});
 
 			
 		}
 
 		return autoSyncTimer;
 	}
 
 	/**
 	 * Returns the time in milliseconds that specify the delay of 
 	 * the auto synchronization.
 	 * 
 	 * @return
 	 */
 	public long getAutoSynchronizeDelay() {
 		return autoSynchronizeDelay;
 	}
 
 	/**
 	 * Sets the autoSynchronization in miliseconds.
 	 * 
 	 * @param autoSynchronizeDelay
 	 * @see #setAutoSynchronize(boolean)
 	 */
 	public void setAutoSynchronizeDelay(long autoSynchronizeDelay) {
 		long oldValue = getAutoSynchronizeDelay();
 		this.autoSynchronizeDelay = autoSynchronizeDelay;
 		
 		getAutoSyncTimer().setDelay((int) autoSynchronizeDelay);
 		getAutoSyncTimer().setInitialDelay((int) autoSynchronizeDelay);
 		allowAutoSync=true;
 		if (autoSynchronize) {
 			getAutoSyncTimer().restart();
 		} else {
 			getAutoSyncTimer().stop();
 		}
 		firePropertyChange("autoSynchronizeDelay", oldValue, this.autoSynchronizeDelay);
 		
 	}
 	
 	/**
 	 * Demonstration.
 	 *
 	 * @param args Command line arguments.
 	 */
 	public static void main(String[] args)
 	{
 		final DialKnob knob = new DialKnob("Voltage");
 		//simulates asymptotical approaching to user value
 		Thread t = new Thread() {
 				private double value;
 				private double initValue;
 				private long timeLastChanged = System.currentTimeMillis();
 
 				public void run()
 				{
 					JFrame frame = new javax.swing.JFrame("DialKnob");
 					frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
 					JPanel panel = new JPanel();
 					frame.setContentPane(panel);
 					frame.setSize(300, 300);
 					knob.setTitleVisible(true);
 					knob.setFormat("%d");
 					knob.setUnits("V");
 					knob.setPopupEnabled(true);
 					knob.setEditable(true);
 					knob.addSetListener(new SetAdapter() {
 							public void setPerformed(SetEvent se)
 							{
 								timeLastChanged = System.currentTimeMillis();
 								initValue = value;
 								
 //								System.out.println(knob.getValue() + " " + knob.getGraphMin() + " " + knob.getGraphMax()+ " " + knob.getUserValue() + " " + knob.getUserMin() + " " + knob.getUserMax());
 							}
 						});
 					panel.setLayout(new java.awt.CardLayout());
 					panel.add(knob, "DialKnob");
 					frame.setVisible(true);
 
 					initValue = value = knob.getUserValue();
 
 					double relaxTime = 50;
 					
 					
 					while (true) {
 						value = knob.getUserValue()
 							+ (initValue - knob.getUserValue()) * Math.exp(-(System
 							    .currentTimeMillis() - timeLastChanged) / relaxTime);
 						knob.setValue(value);
 						System.out.println(value);
 						try {
 							sleep(10);
 						} catch (Exception e) {
 						}
 					}
 				}
 			};
 				
 		t.run();
 		 
 	}
 }
 
 /* __oOo__ */