/*
    * 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.Color;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.GradientPaint;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.GridLayout;
  import java.awt.Rectangle;
  import java.awt.event.ActionEvent;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.awt.image.BufferedImage;
  import java.beans.Beans;
  import java.util.Timer;
  import java.util.TimerTask;
  import javax.swing.AbstractAction;
  import javax.swing.JComponent;
  import javax.swing.JPanel;
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateOriginator;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.range2.RangedValueController;
  import com.cosylab.gui.components.range2.LinearRange;
  import com.cosylab.gui.components.range2.LogarithmicRange;
  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.Tick;
  import com.cosylab.gui.components.range2.TickParameters;
  import com.cosylab.gui.components.range2.TrimValuePolicy;
  import com.cosylab.gui.components.util.ActionList;
  import com.cosylab.gui.components.util.ColorHelper;
  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 numerical (<code>double</code>) values
   * using a liquid partially filled vertical tube visualisation. A value label
   * above the pipe displays the textural value together vith possible units.
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   */
  public class Piper extends JComponent implements PopupManageable,
  	StateOriginator
  {
  	/**
  	 * Defines the orietation of the piper. Orientation defines how the piper is
  	 * drawn, on which side are max/min. 
  	 * <ul>
  	 * <li> BOTTOM_UP - lower bound is on the bottom, pipe is filled from bottom to top </li>
  	 * <li> LEFT_RIGHT - lower bound is on the left, pipe is filled from left to right </li>
  	 * <li> RIGHT_LEFT - lower bound is on the right, pipe is filled from right to left </li>
  	 * <li> TOP_DOWN - lower bound is on the top, pipe is filled from the top to the bottom </li>
  	 * </ul>
  	 * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
  	 * @version $Id: Piper.java,v 1.30 2008-05-19 06:49:05 jbobnar Exp $
  	 *
  	 */
  	public enum LayoutOrientation {
  		BOTTOM_UP, LEFT_RIGHT, TOP_DOWN, RIGHT_LEFT
  	}
  		
  	private static final long serialVersionUID = 1L;
  	/*
  	 * An extension of Timer used for periodic tilting of the Wheelswitch.
  	 *
  	 * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
  	 * @version $id$
 	 *
 	 */
 	protected class TiltHandler extends Timer
 	{
 		private class TiltTask extends TimerTask
 		{
 			/**
 			 * DOCUMENT ME!
 			 */
 			public void run()
 			{
 				if (numberOfTilts >= MAX_NUMBER_OF_TILTS) {
 					cancel();
 					tilting = false;
 				} else {
 					numberOfTilts++;
 					tilting = !tilting;
 				}
 
 				renderer.clearBuffer();
 				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;
 			}
 		}
 	}
 
 	private class PiperRenderer implements TickParameters /* implements TickCallback - edit apikus */
 	{
 		private Graphics2D g;
 		private Rectangle pipeRect;
 		private Rectangle pipeRectOrg;
 		private int arcRadius;
 		private BufferedImage pipeImage;
 		private BufferedImage scaleImage;
 		private BufferedImage tickImage;
 		private final Color DARK_COLOR = new Color(0, 0, 10);
 		private final Color LIGHT_COLOR = new Color(50, 150, 250);
 		private final Color OUT_OF_BOUNDS_DARK_COLOR = new Color(250, 120, 10);
 		private final Color OUT_OF_BOUNDS_LIGHT_COLOR = new Color(250, 250, 50);
 		private Color darkColor;
 		private Color ligtColor;
 		private Color outOfBoundsDarkColor;
 		private Color outOfBoundsLightColor;
 		private Tick[] ticks;
 		
 		public PiperRenderer() {
 			darkColor = DARK_COLOR;
 			ligtColor = LIGHT_COLOR;
 			outOfBoundsDarkColor = OUT_OF_BOUNDS_DARK_COLOR;
 			outOfBoundsLightColor = OUT_OF_BOUNDS_LIGHT_COLOR;
 		}
 
 		private int getPiperWidth() {
 			if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.TOP_DOWN) {
 				return getWidth();
 			} else if (orientation == LayoutOrientation.LEFT_RIGHT || orientation == LayoutOrientation.RIGHT_LEFT) {
 				return getHeight();
 			}
 			return 0;
 		}
 		
 		private int getPiperHeight() {
 			if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.TOP_DOWN) {
 				return getHeight();
 			} else if (orientation == LayoutOrientation.LEFT_RIGHT || orientation == LayoutOrientation.RIGHT_LEFT) {
 				return getWidth();
 			}
 			return 0;
 		}
 		
 		private int transformXToOrientation(int x, int piperWidth) {
 			if (orientation == LayoutOrientation.TOP_DOWN) {
 				return getWidth() - x - piperWidth;
 			} else if (orientation == LayoutOrientation.RIGHT_LEFT) {
 				return getHeight() - x - piperWidth;
 			} else {
 				return x;
 			}
 		}
 		
 		/**
 		 * Clears image buffers.
 		 */
 		public void clearBuffer() {
 			synchronized (renderer) {
 				pipeImage = null;
 				scaleImage = null;
 				tickImage = null;
 				pipeRect = null;
 				pipeRectOrg = null;
 				ticks = null;
 				arcRadius = 0;
 			}
 		}
 		
 		/**
 		 * Gets the size of the scale text.
 		 *
 		 * @param position double
 		 * @param text String
 		 *
 		 * @return int
 		 *
 		 * @see com.cosylab.gui.components.range.TickCallback#measureTick(double,
 		 *      java.lang.String)
 		 */
 		public int measureTick(double position, String text)
 		{
 			if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.TOP_DOWN) {
 				return g.getFontMetrics().getHeight();
 			} else {
 				return g.getFontMetrics().stringWidth(text);
 			}
 		}
 
 		/**
 		 * Paints the liquid fill buffered image on the Graphics supplied. If
 		 * no buffer exists, new one is created.
 		 *
 		 * @param g Graphics2D
 		 */
 		public void paintFill(Graphics2D g)
 		{
 			//setPipeRect(g);
 
 			//System.out.println("FILL " + Piper.this.getSize() + " " + pipeRect);
 
 			int fillHeight = Math.max(1,
 				    (int)Math.round(
 				        rangedValue.getRelativeValue() * (pipeRect.height
 				        - 2 * arcRadius)));
 			int fillWidth = pipeRect.width;
 
 			BufferedImage fillImage = new BufferedImage(fillWidth,
 				    fillHeight + arcRadius, BufferedImage.TYPE_4BYTE_ABGR);
 			Graphics2D g2D = (Graphics2D)fillImage.getGraphics();
 			prepareGraphics(g2D);
 
 			boolean checkValue = (getValue() >= getMinimum()
 				&& getValue() <= getMaximum());
 
 			Color lightColor = (checkValue ? this.ligtColor
 				: outOfBoundsLightColor);
 			Color darkColor = (checkValue ? this.darkColor : outOfBoundsDarkColor);
 
 			if (enhanced) {
 				g2D.setPaint(new GradientPaint(0.f, 0.f, lightColor,
 				        fillWidth, fillHeight, darkColor));
 			} else {
 				g2D.setColor(lightColor);
 			}
 
 			g2D.fillRect(0, 0, fillWidth, fillHeight);
 			g2D.fillArc(0, fillHeight - arcRadius, 2 * arcRadius,
 			    2 * arcRadius, 180, 270);
 			g2D.fillArc(fillWidth - 2 * arcRadius, fillHeight - arcRadius,
 			    2 * arcRadius, 2 * arcRadius, 270, 360);
 
 			if (arcRadius < fillWidth) {
 				g2D.fillRect(arcRadius, fillHeight, fillWidth - 2 * arcRadius,
 				    arcRadius);
 			}
 
 			if (enhanced) {
 				g.setComposite(AlphaComposite.getInstance(
 				        AlphaComposite.SRC_OVER, 0.5f));
 			}
 			
 			g.drawImage(fillImage, null, pipeRect.x,
 			    pipeRect.y + pipeRect.height - arcRadius - fillHeight);
 
 			//System.out.println("VALUE "+rangedValue.getRelativeValue()+" "+fillHeight+" "+pipeRect.y+" "+ pipeRect.height +" "+ arcRadius +" "+ fillHeight);
 			if (enhanced) {
 				g.setComposite(AlphaComposite.getInstance(
 				        AlphaComposite.SRC_OVER, 1.f));
 			}
 		}
 
 		/**
 		 * Paints the value label showing the actual value dipalyed on the
 		 * Graphics supplied.
 		 *
 		 * @param g Graphics2D
 		 */
 		public void paintLabel(Graphics2D g)
 		{
 			//setPipeRect(g);
 
 			String unitText = units;
 
 			if (units == null && Beans.isDesignTime()) {
 				unitText = "<u>";
 			}
 
 			if (unitText == null || !unitsVisible) {
 				unitText = "";
 			}
 
 			String text;
 
 			try {
 				//text = formatter.sprintf(labelValue); /* edit apikus */
 				text = this.formatNumber(labelValue);
 			} catch (Exception e) {
 				text = Double.toString(labelValue);
 			}
 
 			text += (units == null ? "" : " " + unitText);
 
 			int textWidth = g.getFontMetrics().stringWidth(text);
 			int textHeight = g.getFontMetrics().getAscent();
 
 			// workaround - Java bug
 			textHeight = (int)(textHeight * 0.7) + 1;
 			int botLeftX;
 			int botLeftY;
 			
 			if (orientation == LayoutOrientation.LEFT_RIGHT || orientation == LayoutOrientation.RIGHT_LEFT) {
 				botLeftX = pipeRectOrg.y + (pipeRectOrg.height - textWidth) / 2;
 				botLeftY = getHeight() - (getHeight() - (pipeRectOrg.x + pipeRectOrg.width))/2 + textHeight;
 			} else {
 				botLeftX = pipeRectOrg.x + (pipeRectOrg.width - textWidth) / 2;
 				botLeftY = pipeRectOrg.y + pipeRectOrg.height + (textHeight + pipeRectOrg.y) / 2;
 				if (orientation == LayoutOrientation.BOTTOM_UP) {
 					if (!titleVisible) {
 						botLeftY += g.getFontMetrics().getHeight()/2;
 					}
 				} else {
 					if (!titleVisible) {
 						botLeftY -= g.getFontMetrics().getHeight();
 					}
 				}
 			}
 			
 			
 
 			g.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 			g.drawString(text, botLeftX, botLeftY);
 		}
 
 		/**
 		 * Paints the pipe buffered image on the Graphics supplied. If no
 		 * buffer exists, new one is created.
 		 *
 		 * @param g Graphics2D
 		 */
 		public void paintPipe(Graphics2D g)
 		{
 			//setPipeRect(g);
 
 			if (pipeImage == null) {
 				//Debug.out("New pipe image created.");
 				pipeImage = new BufferedImage(pipeRect.width, pipeRect.height,
 					    BufferedImage.TYPE_4BYTE_ABGR);
 
 				Graphics2D g2D = (Graphics2D)pipeImage.getGraphics();
 				prepareGraphics(g2D);
 				g2D.setColor((tilting ? ColorHelper.getAlarm() : Color.WHITE));
 				g2D.fillRoundRect(0, 0, pipeRect.width, pipeRect.height,
 				    2 * arcRadius, 2 * arcRadius);
 			}
 			
 			g.drawImage(pipeImage, null, pipeRect.x, pipeRect.y);
 		}
 
 		private Dimension getTickDim(Graphics g, int pipeHeigth)
 		{
 			Tick[] tcks = getTicks(pipeHeigth);
 			int tckW = 0;
 			int maxLen = 0;
 
 			for (int i = 0; i < tcks.length; i++) {
 				if (tcks[i] != null && tcks[i].text != null
 				    && tcks[i].text.length() > maxLen) {
 					int newW = g.getFontMetrics().stringWidth(tcks[i].text);
 					tckW = Math.max(tckW, newW);
 				}
 			}
 
 			return new Dimension(tckW, g.getFontMetrics().getHeight());
 		}
 
 		private void setPipeRect(Graphics2D g)
 		{
 			if (pipeRect == null) {
 
 				this.g=g;
 
 				int compW = getPiperWidth();
 				int compH = getPiperHeight();
 				int x;
 				int y;
 				int w;
 				int h;
 
 				y = Math.max(1, (int)(6 * Math.atan(compH / 100)));
 				if (orientation == LayoutOrientation.TOP_DOWN) {
 					if (titleVisible) {
 						y += g.getFontMetrics().getHeight();
 						h = Math.max(1, compH - 2 * y);
 					} else { 
 						y += g.getFontMetrics().getHeight();
 						h = Math.max(1, compH - 2 * y + g.getFontMetrics().getHeight());
 					}
 				} else if (orientation == LayoutOrientation.BOTTOM_UP) {
 					if (titleVisible) {
 						y += g.getFontMetrics().getHeight();
 						h = Math.max(1, compH - 2 * y);
 					} else { 
 						h = Math.max(1, compH - 2 * y - g.getFontMetrics().getHeight());
 					}
 
 				} else {
 					h = Math.max(1, compH - 2 * y);
 				}
 
 				Dimension tickDim = getTickDim(g, h);
 
 				if (stretch) {
 					x = 10;
 					w = Math.max(1, compW - tickDim.width * 3 / 2 - 2 * x);
 				} else {
 					x = compW * 1 / 5;
 
 					if (10 + tickDim.width > x) {
 						x = (2 * x - 10 - tickDim.width) / 2 + 5;
 						w = Math.max(1, compW - x - 10 - tickDim.width);
 					} else {
 						w = Math.max(1, compW - 2 * x);
 					}
 				}
 				
 				pipeRect = new Rectangle(transformXToOrientation(x,w), y, w, h);
 				pipeRectOrg = new Rectangle(x, y, w, h);
 				g=null;
 
 				setArcRadius(pipeRect);
 			}
 		}
 
 		private void setArcRadius(Rectangle pipeRect)
 		{
 			double ratio = pipeRect.height / (double)pipeRect.width;
 
 			if (ratio > 5) {
 				arcRadius = pipeRect.width / 2;
 			} else {
 				arcRadius = (int)Math.max(ratio / 5 * pipeRect.width / 2, 2);
 			}
 		}
 
 		/**
 		 * Paints the scale buffered image on the Graphics supplied. If no
 		 * buffer exists, new one is created.
 		 *
 		 * @param g Graphics2D
 		 */
 		public void paintScale(Graphics2D g)
 		{
 			g.drawImage(getScaleImage(), null, 0, 0);
 		}
 		
 		public void paintTickLabels(Graphics2D g) {
 			
 			g.drawImage(getTickImage(), null, 0, 0);
 		}
 
 		/**
 		 * Paints the title.
 		 *
 		 * @param g
 		 */
 		public void paintTitle(Graphics2D g)
 		{
 			//setPipeRect(g);
 
 			String text = title;
 
 			if (title == null && Beans.isDesignTime()) {
 				text = "<title>";
 			}
 
 			if (text == null || text.length() == 0) {
 				return;
 			}
 
 			int textWidth = g.getFontMetrics().stringWidth(text);
 			int textHeight = g.getFontMetrics().getAscent();
 
 			// workaround - Java bug
 			textHeight = (int)(textHeight * 0.7) + 1;
 			int botLeftX;
 			int botLeftY;
 			
 			if (orientation == LayoutOrientation.LEFT_RIGHT || orientation == LayoutOrientation.RIGHT_LEFT) {
 				botLeftX = pipeRect.y + (pipeRect.height - textWidth) / 2;
 				botLeftY = (textHeight + pipeRectOrg.x) / 2;
 			} else {
 				botLeftX = pipeRectOrg.x + (pipeRectOrg.width - textWidth) / 2;
 				botLeftY = (textHeight + pipeRectOrg.y) / 2;
 			}
 			
 
 			g.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 
 			//g.setFont(FontHelper.getFontWithSize(g.getFont().getSize()*12/10,g.getFont()));
 			g.drawString(text, botLeftX, botLeftY);
 		}
 
 		protected void prepareGraphics(Graphics2D g)
 		{
 			Font f = FontHelper.getDefaultFont();
 
 			if (resizable) {
 				int fontHeight = 5 + Math.min(getWidth(), getHeight() / 2) / 15;
 				if (orientation == LayoutOrientation.LEFT_RIGHT || orientation == LayoutOrientation.RIGHT_LEFT) {
 					f = FontHelper.getFontWithSize((int)(fontHeight*1.5), f);
 				} else {
 					f = FontHelper.getFontWithSize((int)(fontHeight*1.2), f);
 				}
 //				f = FontHelper.getFontWithSize(fontHeight, f);
 			}
 
 			g.setFont(f);
 
 			if (enhanced) {
 				g.addRenderingHints(PaintHelper.getAntialiasingHints());
 			}
 		}
 
 		private BufferedImage getScaleImage()
 		{
 			if (scaleImage == null) {
 				//Debug.out("New scale image created.");
 				int width = getPiperWidth();
 				int height = getPiperHeight();
 
 				scaleImage = new BufferedImage(width, height,
 					    BufferedImage.TYPE_4BYTE_ABGR);
 
 				Graphics2D g2D = (Graphics2D)scaleImage.getGraphics();
 				prepareGraphics(g2D);
 				g2D.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 
 				Font oldFont = g2D.getFont();
 				g2D.setFont(oldFont.deriveFont(Font.PLAIN,
 				        oldFont.getSize2D() * 0.8f));
 
 				//setPipeRect(g2D);
 
 				/*System.out.println("TICKS " + Piper.this.getSize() + " "
 				    + pipeRect);*/
 
 				int spaceWidth = width - pipeRect.x - pipeRect.width;
 
 				int scaleHeight = pipeRect.height - 2 * arcRadius;
 
 				int tickLength = Math.max(pipeRect.width * 3 / 4, 5);
 				int minorTickLength = tickLength / 2;
 
 				if (pipeRect.width > 200) {
 					tickLength = 150 + (pipeRect.width - 200) * 1 / 3;
 					minorTickLength = 75;
 				}
 
 				// Offset from the right edge of the pipe
 				Dimension tickDim = getTickDim(g2D, pipeRect.height);
 				int offsetX = tickDim.height / 2;
 
 				if (2 * offsetX + tickDim.width > spaceWidth) {
 					offsetX = Math.max(1, (spaceWidth - tickDim.width) / 2);
 				}
 
 				Tick[] ticks = getTicks(scaleHeight);
 
 				if (ticks == null) {
 					return scaleImage;
 				}
 
 				for (int i = 0; i < ticks.length; i++) {
 					if (ticks[i].major) {
 						g2D.drawLine(pipeRect.x
 						    + (pipeRect.width - tickLength) / 2,
 						    pipeRect.y + arcRadius
 						    + (int)(scaleHeight * (1. - ticks[i].proportional)),
 						    pipeRect.x + (pipeRect.width + tickLength) / 2 - 1,
 						    pipeRect.y + arcRadius
 						    + (int)(scaleHeight * (1. - ticks[i].proportional)));
 					} else {
 						g2D.drawLine(pipeRect.x
 						    + (pipeRect.width - minorTickLength) / 2,
 						    pipeRect.y + arcRadius
 						    + (int)(scaleHeight * (1. - ticks[i].proportional)),
 						    pipeRect.x + (pipeRect.width + minorTickLength) / 2
 						    - 1,
 						    pipeRect.y + arcRadius
 						    + (int)(scaleHeight * (1. - ticks[i].proportional)));
 					}
 				}
 			}
 
 			return scaleImage;
 		}
 		
 		private BufferedImage getTickImage()
 		{
 			if (tickImage == null) {
 				int width;
 				int height;
 				if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.TOP_DOWN) {
 					width = getPiperWidth();
 					height = getPiperHeight();	
 				} else {
 					width = getPiperHeight();
 					height = getPiperWidth();
 				}
 				
 				tickImage = new BufferedImage(width, height,
 					    BufferedImage.TYPE_4BYTE_ABGR);
 				
 				Graphics2D g2D = (Graphics2D)tickImage.getGraphics();
 				prepareGraphics(g2D);
 				g2D.setColor((isEnabled() ? Color.BLACK : Color.GRAY));
 
 				Font oldFont = g2D.getFont();
 				g2D.setFont(oldFont.deriveFont(Font.PLAIN,
 				        oldFont.getSize2D() * 0.8f));
 
 				int spaceWidth = width - pipeRectOrg.x - pipeRectOrg.width;
 				int scaleHeight = pipeRect.height - 2 * arcRadius;
 
 				Dimension tickDim = getTickDim(g2D, pipeRectOrg.height);
 				int offsetX = tickDim.height / 2;
 
 				if (orientation == LayoutOrientation.TOP_DOWN || orientation == LayoutOrientation.BOTTOM_UP) {
 					if (2 * offsetX + tickDim.width > spaceWidth) {
 						offsetX = Math.max(1, (spaceWidth - tickDim.width) / 2);
 					}
 				}				
 
 				Tick[] ticks = getTicks(scaleHeight);
 
 				if (ticks == null) {
 					return tickImage;
 				}
 
 				int textPosX = pipeRectOrg.x + pipeRectOrg.width + offsetX;
 								
 				if (orientation == LayoutOrientation.TOP_DOWN) {
 					int y0 = pipeRectOrg.y;
 					if (!titleVisible) {
 						y0 -= g.getFontMetrics().getHeight();
 					}
 					for (int i = 0; i < ticks.length; i++) {
 						if (ticks[i].major) {
 							g2D.drawString(ticks[i].text,
 									textPosX,
 									pipeRectOrg.y + arcRadius
 								    + (int)(scaleHeight * (ticks[i].proportional))
 								    + 5);	
 						} 
 					}
 				} else if(orientation == LayoutOrientation.BOTTOM_UP) {
 					for (int i = 0; i < ticks.length; i++) {
 						if (ticks[i].major) {
 							g2D.drawString(ticks[i].text,
 									textPosX,
 									pipeRectOrg.y + arcRadius
 								    + (int)(scaleHeight * (1-ticks[i].proportional))
 								    + 5);	
 						} 
 					}
 				} else if (orientation == LayoutOrientation.LEFT_RIGHT){
 					for (int i = 0; i < ticks.length; i++) {
 						if (ticks[i].major && ticks[i].text != null && ticks[i].text.length() != 0) {
 							g2D.drawString(ticks[i].text,
 									pipeRectOrg.y + arcRadius
 								    + (int)(scaleHeight * (ticks[i].proportional))
 								    - tickDim.width/2, textPosX + 5);
 						} 
 					}
 				} else if (orientation == LayoutOrientation.RIGHT_LEFT) {
 					for (int i = 0; i < ticks.length; i++) {
 						if (ticks[i].major) {
 							g2D.drawString(ticks[i].text,
 									pipeRectOrg.y + arcRadius
 								    + (int)(scaleHeight * (1-ticks[i].proportional))
 								    - tickDim.width/2, textPosX + 5);	
 						} 
 					}
 				}
 				
 			}
 
 			return tickImage;
 		}
 
 		private Tick[] getTicks(int height)
 		{
 			if (ticks == null) {
 				//ticks = rangedValue.getRange().getTicks(height).toTicks(this); /* edit apikus */
 				ticks = rangedValue.calculateTicks(height,this);
 			}
 
 			return ticks;
 		}
 		
 		public String formatNumber(double x) { /* Use this method - edit apikus */
 			return formatter.sprintf(x);
 		}
 	}
 
 	private class ResizeListener extends ComponentAdapter
 	{
 		/**
 		 * Listens for component events and resizes the component accordingly.
 		 *
 		 * @param e ComponentEvent
 		 *
 		 * @see java.awt.event.ComponentListener#componentResized(ComponentEvent)
 		 */
 		public void componentResized(ComponentEvent e)
 		{
 			Piper.this.setSize(getBounds().width, getBounds().height);
 			renderer.clearBuffer(); /* edit apikus */
 			repaint();
 		}
 	}
 
 	private class ValueListener implements RangedValueListener
 	{
 		/**
 		 * Listens for value changes and redraws the component accordingly.
 		 *
 		 * @param event RangedValueEvent
 		 *
 		 * @see com.cosylab.gui.components.range.RangedValueListener#valueChanged(RangedValueEvent)
 		 */
 		public void valueChanged(RangedValueEvent event)
 		{
 			if (event.isMinimumChanged() || event.isMaximumChanged()) {
 				renderer.clearBuffer();
 
 				if (!isEnabled()) {
 					return;
 				}
 				repaint();
 			}
 
 			if (event.isValueChanged()) {
 				if (!isEnabled()) {
 					return;
 				}
 				repaint();
 			}
 		}
 	}
 
 	private RangedValuePolicy policy;
 	private AbstractCustomizerPanel customizer;
 	private PiperRenderer renderer;
 	private PopupManager popupManager;
 	private PrintfFormat formatter;
 	//private RangedValue rangedValue; /* edit apikus */
 	private RangedValueController rangedValue;
 	private String format;
 	private String title;
 	private boolean titleVisible;
 	private int titleMinimumFontSize;
 	private int titleMaximumFontSize;
 	private String units;
 	private TiltHandler tiltHandler;
 	private boolean enhanced = true;
 	private boolean logarithmic;
 	private boolean popupEnabled;
 	private boolean resizable = true;
 	private boolean stretch = false;
 	private boolean tilting;
 	private boolean tiltingEnabled;
 	private double labelValue;
 	private boolean unitsVisible = true;
 	
 	private LayoutOrientation orientation = LayoutOrientation.BOTTOM_UP;
 
 	/**
 	 * Creates a new Piper displaying the specified value.
 	 *
 	 * @param newValue double
 	 */
 	public Piper(double newValue)
 	{
 		super();
 
 		renderer = new PiperRenderer();
 
 		format = "%3.2f";
 		formatter = new PrintfFormat(format);
 
 		policy = new TrimValuePolicy();
 
 		labelValue = newValue;
 
 		rangedValue = new RangedValueController(); /* edit apikus */
 		rangedValue.setValue(0, 1, newValue);
 		rangedValue.setRange(new LinearRange());
 		rangedValue.addPolicy(policy);
 		rangedValue.addRangedValueListener(new ValueListener());
 
 		addComponentListener(new ResizeListener());
 
 		setBackground(ColorHelper.getCosyControl());
 		setPreferredSize(new Dimension(150, 300));
 		setMinimumSize(new Dimension(60, 100));
 		setVisible(true);
 		setOpaque(true);
 		setPopupEnabled(true);
 	}
 
 	/**
 	 * Creates a new Piper with zero value.
 	 */
 	public Piper()
 	{
 		this(0);
 	}
 
 	/**
 	 * Returns the Customizer intance for this displayer.
 	 *
 	 * @return the Customizer intance for this displayer
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 		}
 
 		return customizer;
 	}
 
 	/**
 	 * Triggers on and off the visually enhanced mode of the Piper. When
 	 * enhanced, the liquid filling is painted with a gradient color and
 	 * anti-aliasing is used.
 	 *
 	 * @param enhanced
 	 */
 	public void setEnhanced(boolean enhanced)
 	{
 		if (this.enhanced == enhanced) {
 			return;
 		}
 
 		boolean oldEnhanced = this.enhanced;
 		this.enhanced = enhanced;
 		renderer.clearBuffer(); /* edit apikus */
 		repaint();
 		firePropertyChange("enhanced", oldEnhanced, enhanced);
 	}
 
 	/**
 	 * Returns wether the component visualisation is enhanced.
 	 *
 	 * @return boolean
 	 */
 	public boolean isEnhanced()
 	{
 		return enhanced;
 	}
 
 	/**
 	 * Sets the format of the value label text.
 	 *
 	 * @param format The format to set
 	 */
 	public void setFormat(String format)
 	{
 		String oldFormat = this.format;
 
 		if (format == null && oldFormat == null
 		    || format != null && format.equals(oldFormat)) {
 			return;
 		}
 
 		this.format = format;
 		formatter = new PrintfFormat(format);
 		firePropertyChange("format", oldFormat, format);
 		renderer.clearBuffer();
 		if (!isEnabled()) {
 			return;
 		}
 		
 		repaint();
 	}
 
 	/**
 	 * Returns the format of the value label text.
 	 *
 	 * @return String
 	 */
 	public String getFormat()
 	{
 		return format;
 	}
 
 	/**
 	 * Sets the new maximum value displayed at the top of the scale of the
 	 * Piper. This method delegates all logic to the RangedValue
 	 * implementation.
 	 *
 	 * @param newMaximum double
 	 */
 	public void setMaximum(double newMaximum)
 	{
 		double oldMaximum = rangedValue.getMaximum();
 
 		//if (oldMaximum == newMaximum) {
 		//	return;
 		//}
 		rangedValue.setValue(rangedValue.getMinimum(), newMaximum,
 		    rangedValue.getValue());
 		firePropertyChange("maximum", oldMaximum, newMaximum);
 	}
 
 	/**
 	 * Returns the maximum value displayed at the top of the scale of the
 	 * Piper.
 	 *
 	 * @return double
 	 */
 	public double getMaximum()
 	{
 		return rangedValue.getMaximum();
 	}
 
 	/**
 	 * Sets the new minimum value displayed at the bottom of the scale of the
 	 * Piper. This method delegates all logic to the RangedValue
 	 * implementation.
 	 *
 	 * @param newMinimum double
 	 */
 	public void setMinimum(double newMinimum)
 	{
 		double oldMinimum = rangedValue.getMinimum();
 
 		//if (oldMinimum == newMinimum) {
 		//	return;
 		//}
 		rangedValue.setValue(newMinimum, rangedValue.getMaximum(),
 		    rangedValue.getValue());
 		firePropertyChange("minimum", oldMinimum, newMinimum);
 	}
 
 	/**
 	 * Gets the minimum value displayed at the bottom of the scale of the
 	 * Piper.
 	 *
 	 * @return double
 	 */
 	public double getMinimum()
 	{
 		return rangedValue.getMinimum();
 	}
 
 	/**
 	 * Switches between linear and logarithmic scales displayed. This method
 	 * delegates all logic to the RangedValue implementation.
 	 *
 	 * @param logScale boolean
 	 */
 	public void setLogarithmic(boolean logScale)
 	{
 		if (logScale == logarithmic) {
 			return;
 		}
 
 		logarithmic = logScale;
 
 		if (logScale) {
 			rangedValue.setRange(new LogarithmicRange());
 		} else {
 			rangedValue.setRange(new LinearRange());
 		}
 
 		firePropertyChange("logarithmic", !logScale, logScale);
 	}
 
 	/**
 	 * Returns <code>true</code> if the display is in logarithmic scale.
 	 *
 	 * @return boolean
 	 */
 	public boolean isLogarithmic()
 	{
 		return logarithmic;
 	}
 
 	/**
 	 * Sets both minimum and maximum displayed values displayed  at the bottom
 	 * and at the top of the Pipers's scale. This method delegates all logic
 	 * to the RangedValue implementation.
 	 *
 	 * @param newMax double
 	 * @param newMin double
 	 */
 	public void setMaxMin(double newMax, double newMin)
 	{
 		double oldMaximum = rangedValue.getMaximum();
 		double oldMinimum = rangedValue.getMinimum();
 
 		if (oldMaximum == newMax && oldMinimum == newMin) {
 			return;
 		}
 
 		rangedValue.setValue(newMin, newMax, rangedValue.getValue());
 		firePropertyChange("maximum", oldMaximum, newMax);
 		firePropertyChange("minimum", oldMinimum, newMin);
 	}
 
 	/**
 	 * 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) return;
 		popupEnabled = b;
 		if (b) {
 			addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			removeMouseListener(getPopupManager().getMouseHook());
 		}
 		firePropertyChange("popupEnabled", !b, b);
 	}
 
 	/**
 	 * 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;
 	}
 
 	/**
 	 * Sets the new value to be displayed. This method delegates all logic to
 	 * the RangedValue implementation.
 	 *
 	 * @param newValue double
 	 */
 	public void setValue(double newValue)
 	{
 		double oldValue = rangedValue.getValue();
 
 		labelValue = newValue;
 
 		//if (oldValue == newValue) {
 		//	return;
 		//}
 		rangedValue.setValue(newValue);
 
 		if ((newValue > rangedValue.getMaximum()
 		    || newValue < rangedValue.getMinimum()) && tiltingEnabled) {
 			getTiltHandler().tilt();
 		}
 
 		firePropertyChange("value", oldValue, newValue);
 	}
 
 	/**
 	 * Returns the value currently displayed.
 	 *
 	 * @return double
 	 */
 	public double getValue()
 	{
 		return labelValue;
 	}
 
 	/**
 	 * For demonstration purposes.
 	 *
 	 * @param args String[]
 	 */
 	public static void main(String[] args)
 	{
 		Thread t = new Thread() {
 				public void run()
 				{
 					javax.swing.JFrame frame = new javax.swing.JFrame();
 					frame.addWindowListener(new WindowAdapter() {
 							public void windowClosing(WindowEvent e)
 							{
 								System.exit(0);
 							}
 						});
 
 					JPanel panel = new JPanel();
 					frame.setContentPane(panel);
 					frame.setSize(new java.awt.Dimension(100, 220));
 
 					Piper sp = new Piper();
 					sp.setEnhanced(true);
 					sp.setPopupEnabled(true);
 //					sp.setStretch(false);
 					sp.setMinimum(-10.0);
 					sp.setMaximum(20.0);
 					sp.setValue(10.0);
 					sp.setTitle("NASLOV");
 					sp.setTitleVisible(false);
 					sp.setLayoutOrientation(LayoutOrientation.LEFT_RIGHT);
 					panel.setLayout(new GridLayout());
 					panel.add(sp);
 					
 					frame.setVisible(true);
 
 					//double x = 5;
 					//int i = 1;
 					//long time1 = System.currentTimeMillis();
 					//long time2 = 0;
 
 					/*while (true) {
 					    time2 = System.currentTimeMillis() - time1;
 					    x = 0.5
 					        + NoiseMaker.perlinNoise((double)time2 / 100.0 * Math.PI / 180);
 
 					    //sp.setValue(x);
 					    //sp.setValue(0.5);
 					    sp.repaint();
 
 					    try {
 					        i++;
 
 					        if (i > 50) {
 					            i = 0;
 					        }
 
 					        sleep(10);
 					    } catch (Exception e) {
 					    }
 					}*/
 				}
 			};
 
 		t.run();
 	}
 
 	/**
 	 * 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();
 	}
 
 	/**
 	 * Returns popup manager for adding popup actions.
 	 *
 	 * @see com.cosylab.gui.components.util.PopupManageable#getPopupManager()
 	 */
 	public PopupManager getPopupManager()
 	{
 		if (popupManager == null) {
 			popupManager = new PopupManager(this, false);
 			popupManager.addAction(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						getCustomizer().showDialog();
 					}
 				});
 
 			//JMenu submenu = new JMenu("Capture screen");
 
 			ActionList al=new ActionList("Capture screen");
 
 			al.addAction(new AbstractAction("To file...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						ScreenCapturer sc = new ScreenCapturer(Piper.this);
 						sc.showScreenDialog();
 					}
 				});
 			/*al.addAction(new AbstractAction("To clipboard...") {
 				public void actionPerformed(ActionEvent e)
 				{
 					ScreenCapturer sc = new ScreenCapturer();
 					sc.saveImageToSysClipBoard(Piper.this);
 				}
 			});*/
 		   popupManager.addAction(al);
 
 		}
 
 		return popupManager;
 	}
 
 	/**
 	 * Sets the resizable property of the component. If set, all components
 	 * text is rendered in font size, adjusted to the size of the whole
 	 * component.
 	 *
 	 * @param b
 	 */
 	public void setResizable(boolean b)
 	{
 		if (b == resizable) {
 			return;
 		}
 		boolean oldResizable = resizable;
 
 		resizable = b;
 
 		firePropertyChange("resizable", oldResizable, resizable);
 		renderer.clearBuffer();
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Returns the resizable property of the component.
 	 *
 	 * @return resizable
 	 */
 	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()));
 		setLogarithmic(state.getBoolean("logarithmic", isLogarithmic()));
 		setStretch(state.getBoolean("stretch", isStretch()));
 		setEnhanced(state.getBoolean("enhanced", isEnhanced()));
 		setResizable(state.getBoolean("resizable", isResizable()));
 		setPopupEnabled(state.getBoolean("popupEnabled", isPopupEnabled()));
 		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("graphMax", getMaximum());
 		state.putDouble("graphMin", getMinimum());
 		state.putString("title", getTitle());
 		state.putString("units", getUnits());
 		state.putBoolean("logarithmic", isLogarithmic());
 		state.putBoolean("stretch", isStretch());
 		state.putBoolean("enhanced", isEnhanced());
 		state.putBoolean("resizable", isResizable());
 		state.putBoolean("popupEnabled", isPopupEnabled());
 		state.putBoolean("tiltingEnabled", isTiltingEnabled());
 
 		return state;
 	}
 
 	/**
 	 * Sets if the pipe should strech all across the width of the component or
 	 * not.
 	 *
 	 * @param b
 	 */
 	public void setStretch(boolean b)
 	{
 		if (b == stretch) {
 			return;
 		}
 
 		boolean oldStretch = stretch;
 		stretch = b;
 		renderer.clearBuffer();
 		firePropertyChange("stretch", oldStretch, stretch);
 
 		if (!isEnabled()) {
 			return;
 		}
 		repaint();
 	}
 
 	/**
 	 * Returns wether the pipe should strech all across the width of the
 	 * component or not.
 	 *
 	 * @return strech
 	 */
 	public boolean isStretch()
 	{
 		return stretch;
 	}
 
 	/**
 	 * Sets the tilitng enabled property.
 	 *
 	 * @param b whether the component should tilt when value is out of bounds.
 	 */
 	public void setTiltingEnabled(boolean b)
 	{
 		if (tiltingEnabled == b) {
 			return;
 		}
 
 		tiltingEnabled = b;
 		firePropertyChange("tiltingEnabled", !b, b);
 	}
 
 	/**
 	 * Returns whether the component should indicate value out of bounds
 	 * condition by visually tilting its border.
 	 *
 	 * @return boolean
 	 */
 	public boolean isTiltingEnabled()
 	{
 		return tiltingEnabled;
 	}
 
 	/**
 	 * Sets the title to be rendered on top of the component when not
 	 * stretched. Can be null in which case nothing is rendered.
 	 *
 	 * @param string title
 	 */
 	public void setTitle(String string)
 	{
 		if (string == null && title == null
 		    || string != null && string.equals(title)) {
 			return;
 		}
 
 		String oldTitle = title;
 
 		title = string;
 		firePropertyChange("title", oldTitle, title);
 
 		if (!isEnabled()) {
 			return;
 		}
 
 		repaint();
 	}
 
 	/**
 	 * Returns the current title of the component or null is none is set.
 	 *
 	 * @return title
 	 */
 	public String getTitle()
 	{
 		return title;
 	}
 
 	/**
 	 * Sets the units to be displayed in the value label. If null, nothing is
 	 * rendered.
 	 *
 	 * @param units The units to set, can be null
 	 */
 	public void setUnits(String units)
 	{
 		if (this.units == null && units == null
 		    || units != null && units.equals(this.units)) {
 			return;
 		}
 
 		String oldUnits = this.units;
 		this.units = units;
 		firePropertyChange("units", oldUnits, units);
 		
 		if (!isEnabled()) {
 			return;
 		}
 		repaint();
 	}
 
 	/**
 	 * Returns the units to be displayed in the value label or null is none is
 	 * set.
 	 *
 	 * @return String
 	 */
 	public String getUnits()
 	{
 		return units;
 	}
 
 	/**
 	 * Returns the rangedValue object containing all the value logic.
 	 *
 	 * @return RangedValue
 	 */
 	protected RangedValueController getRangedValue()
 	{
 		return rangedValue;
 	}
 	
 	/**
 	 * Sets the orientation of the pipe. Pipe's bounds are position according to
 	 * the orientation (eg. TOP_DOWN means that lower values are printed at the
 	 * top of the piper and higher at the bottom; piper is filled from the top
 	 * down).
 	 * 
 	 * @param orientation
 	 */
 	public void setLayoutOrientation(LayoutOrientation orientation) {
 		if (this.orientation == orientation) return;
 		LayoutOrientation oldValue = this.orientation;
 		this.orientation = orientation;
 		firePropertyChange("layoutOrientation", oldValue, orientation);
 		repaint();
 	}
 	
 	/**
 	 * Returns the layout orientation.
 	 * 
 	 * @return
 	 */
 	public LayoutOrientation getLayoutOrientation() {
 		return orientation;
 	}
 	
 	private double getAngle() {
 		if (orientation == LayoutOrientation.BOTTOM_UP) {
 			return 0;
 		} else if (orientation == LayoutOrientation.LEFT_RIGHT) {
 			return Math.PI/2;
 		} else if (orientation == LayoutOrientation.TOP_DOWN) {
 			return Math.PI;
 		} else if (orientation == LayoutOrientation.RIGHT_LEFT) {
 			return 3*Math.PI/2;
 		}
 		return 0;
 	}
 	
 	private double getHorizontalShift() {
 		if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.RIGHT_LEFT) {
 			return 0;
 		} else {
 			return getWidth();
 		} 
 	}
 	
 	private double getVerticalShift() {
 		if (orientation == LayoutOrientation.BOTTOM_UP || orientation == LayoutOrientation.LEFT_RIGHT) {
 			return 0;
 		} else {
 			return getHeight();
 		}
 	}
 		
 	/**
 	 * This method has been overriden to implement custom painting of the
 	 * Piper.
 	 *
 	 * @param g Graphics
 	 *
 	 * @see JComponent#paintComponent(java.awt.Graphics)
 	 */
 	protected void paintComponent(Graphics g)
 	{
 		if (isOpaque()) {
 			g.setColor(getBackground());
 			g.fillRect(0, 0, getWidth(), getHeight());
 		}
 		
 		((Graphics2D)g).translate(getHorizontalShift(),getVerticalShift());
 		((Graphics2D)g).rotate(getAngle());
 		
 		Graphics2D g2D = (Graphics2D)g;
 		g2D.setBackground(getBackground());
 		synchronized (renderer) {
 		
 			
 			renderer.prepareGraphics(g2D);
 			renderer.setPipeRect(g2D);
 			renderer.paintPipe(g2D);
 			renderer.paintFill(g2D);
 			renderer.paintScale(g2D);
 			
 			((Graphics2D)g).rotate(-getAngle());
 			((Graphics2D)g).translate(-getHorizontalShift(),-getVerticalShift());
 			renderer.paintTickLabels(g2D);
 			renderer.paintLabel(g2D);
 			if (titleVisible)
 				renderer.paintTitle(g2D);
 		}
 		
 
 //		g.dispose();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	private TiltHandler getTiltHandler()
 	{
 		if (tiltHandler == null) {
 			tiltHandler = new TiltHandler();
 		}
 
 		return tiltHandler;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param p DOCUMENT ME!
 	 */
 	public void setValuePolicy(RangedValuePolicy p)
 	{
 		rangedValue.removePolicy(policy);
 		this.policy = p;
 		rangedValue.addPolicy(p);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return
 	 */
 	public RangedValuePolicy getValuePolicy()
 	{
 		return policy;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return
 	 */
 	public boolean isUnitsVisible()
 	{
 		return unitsVisible;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param b
 	 */
 	public void setUnitsVisible(boolean b)
 	{
 		if (unitsVisible == b) {
 			return;
 		}
 
 		boolean oldB = unitsVisible;
 		unitsVisible = b;
 		firePropertyChange("unitsVisible", oldB, b);
 		renderer.clearBuffer(); /* edit apikus */
 		repaint();
 	}
 
 	public boolean isTitleVisible() {
 		return titleVisible;
 	}
 
 	public void setTitleVisible(boolean titleVisible) {
 		if (this.titleVisible == titleVisible) {
 			return;
 		}
 
 		this.titleVisible = titleVisible;
 		firePropertyChange("titleVisible", !titleVisible, titleVisible);
 		repaint();
 	}
 
 	public int getTitleMaximumFontSize() {
 		return titleMaximumFontSize;
 	}
 
 	public void setTitleMaximumFontSize(int titleMaximumFontSize) {
 
 		if (this.titleMaximumFontSize == titleMaximumFontSize) return;
 		int i = this.titleMaximumFontSize;
 		this.titleMaximumFontSize = titleMaximumFontSize;
 		firePropertyChange("titleMaximumFontSize", i, titleMaximumFontSize);
 	}
 
 	public int getTitleMinimumFontSize() {
 		return titleMinimumFontSize;
 	}
 
 	public void setTitleMinimumFontSize(int titleMinimumFontSize) {
 		if (this.titleMinimumFontSize == titleMinimumFontSize) return;
 		int i = this.titleMinimumFontSize;
 		this.titleMinimumFontSize = titleMinimumFontSize;
 		firePropertyChange("titleMinimumFontSize", i, titleMinimumFontSize);
 	}
 	
 	/**
 	 * Sets the light color of the water in the piper.
 	 * 
 	 * @param color
 	 */
 	public void setLightWaterColor(Color color) {
 		Color old = renderer.ligtColor;
 		renderer.ligtColor = color;
 		firePropertyChange("lightWaterColor", old, color);
 	}
 	
 	/**
 	 * Sets the dark color of the water in the piper.
 	 * 
 	 * @param color
 	 */
 	public void setDarkWaterColor(Color color) {
 		Color old = renderer.darkColor;
 		renderer.darkColor = color;
 		firePropertyChange("darkWaterColor", old, color);
 	}
 
 	/**
 	 * Sets the light color of the water in case value is out of bounds.
 	 * 
 	 * @param color
 	 */
 	public void setOutOfBoundsLightWaterColor(Color color) {
 		Color old = renderer.outOfBoundsLightColor;
 		renderer.outOfBoundsLightColor = color;
 		firePropertyChange("outOfBoundsLightWaterColor", old, color);
 	}
 
 	/**
 	 * Sets the dark color of the water in case value is out of bounds.
 	 * 
 	 * @param color
 	 */
 	public void setOutOfBoundsDarkWaterColor(Color color) {
 		Color old = renderer.outOfBoundsDarkColor;
 		renderer.outOfBoundsDarkColor = color;
 		firePropertyChange("outOfBoundsDarkWaterColor", old, color);
 	}
 	
 	/**
 	 * @return the light color of the water in the piper
 	 */
 	public Color getLightWaterColor() {
 			return renderer.ligtColor;
 	}
 	
 	/**
 	 * @return the dark color of the water in the piper
 	 */
 	public Color getDarkWaterColor() {
 			return renderer.darkColor;
 	}
 	
 	/**
 	 * @return the light color of the water in case value is out of bounds
 	 */
 	public Color getOutOfBoundsLightWaterColor() {
 			return renderer.outOfBoundsLightColor;
 	}
 	
 	/**
 	 * @return the dark color of the water in case value is out of bounds
 	 */
 	public Color getOutOfBoundsDarkWaterColor() {
 			return renderer.outOfBoundsDarkColor;		
 	}
 }
 
 /* __oOo__ */