/*
    * 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.slider;
  
  import java.awt.AlphaComposite;
  import java.awt.Color;
  import java.awt.FontMetrics;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Rectangle;
  import java.awt.image.BufferedImage;
  
  import javax.swing.Icon;
  import javax.swing.JComponent;
  import javax.swing.JSlider;
  import javax.swing.plaf.metal.MetalSliderUI;
  
  import com.cosylab.gui.components.range2.RangedValueController;
  import com.cosylab.gui.components.range2.Tick;
  import com.cosylab.gui.components.range2.TickParameters;
  import com.cosylab.util.PrintfFormat;
  
  
  /**
   * This is customized Swing l&f for JSlider. 
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @version $id$
   */
  public class CosySliderUI extends MetalSliderUI
  {
  	private boolean checkValue;
  	protected Icon vertTrailerIcon = null;
  	protected BufferedImage horizTrailerBuffer = null;
  	private AlphaComposite alphaComposite;
  	protected Rectangle trailerRect = new Rectangle(0, 0, 16, 16);
  	protected Rectangle trailerCache = new Rectangle();
  	protected double trailerPosition = 0;
  	private boolean showIntegerOnly = false;
  	private String format = "%f";
  	private double tolerance = 0.0001;
  	private boolean paintTrailer = true;
  	
  	protected static final Color[] GREEN_LED = {
  		new Color(0, 160, 0), new Color(0, 220, 0), new Color(0, 250, 0)
  	};
  	protected static final Color[] RED_LED = {
  		new Color(160, 0, 0), new Color(220, 0, 0), new Color(250, 0, 0)
  	};
  	protected static final Color[] YELLOW_LED = {
  		new Color(150, 150, 0), new Color(200, 200, 0), new Color(250, 250, 0)
  	};
  	protected static final Color[] GREY_LED = {
  		new Color(64, 64, 64), new Color(128, 128, 128),
  		new Color(160, 160, 160)
  	};
  
  	private class TickMeasurer implements TickParameters
  	{
  		private FontMetrics fm;
  		private PrintfFormat formatter;
  
  		/**
  		 * Creates a new TickMeasurer object.
  		 *
  		 * @param g 
  		 */
  		public TickMeasurer(Graphics g, String format)
  		{
  			fm = g.getFontMetrics();
  			if (format != null)
  				formatter = new PrintfFormat(format);
  		}
  		/*
  		 * (non-Javadoc)
  		 * @see com.cosylab.gui.components.range2.TickParameters#measureTick(double, java.lang.String)
  		 */
  		public int measureTick(double position, String text)
  		{
  			//			System.out.println(fm.stringWidth(text));
  			if(text==null) {
  				return 0;
 			}
 			return fm.stringWidth(text);
 		}
 
 		/*
 		 * (non-Javadoc)
 		 * @see com.cosylab.gui.components.range2.TickParameters#formatNumber(double)
 		 */
 		public String formatNumber(double value) {
 			if (formatter != null)
 				return formatter.sprintf(value);
 			else
 				return null;
 		}
 	}
 
 	private RangedValueController rangedValue;
 
 	/**
 	 * Creates a new CosySliderUI object.
 	 *
 	 * @param range 
 	 */
 	public CosySliderUI(RangedValueController range)
 	{
 		super();
 		rangedValue = range;
 		alphaComposite = AlphaComposite.getInstance(AlphaComposite.DST_OVER,
 			    (float)0.35);
 	}
 
 	private void renderHorizontalTrailer(Graphics g)
 	{
 		int[] xPoints = { 1, 14, 15, 15, 8, 0, 0 };
 		int[] yPoints = { 0, 0, 1, 9, 16, 9, 1 };
 				
 		g.setColor((checkValue ? Color.black : YELLOW_LED[0]));
 		g.fillPolygon(xPoints, yPoints, xPoints.length);
 	}
 
 	/**
 	 * Returns the image used to display the trailer. This method uses lazy
 	 * initialization and loads the image using the IconHelper class.
 	 *
 	 * @return BufferedImage
 	 */
 	protected BufferedImage getTrailer()
 	{
 		if(horizTrailerBuffer == null) {
 			//Icon horizTrailerIcon = null;
 
 			//try {
 			//	horizTrailerIcon = IconHelper.createIcon(
 			//		    "/icons/specific/SliderTrailer16.gif");
 			//	trailerRect.width = horizTrailerIcon.getIconWidth();
 			//	trailerRect.height = horizTrailerIcon.getIconHeight();
 
 				trailerCache.width = trailerRect.width;
 				trailerCache.height = trailerRect.height;
 			//} catch(Exception e) {
 			//}
 
 			horizTrailerBuffer = new BufferedImage(16, 16,
 				    BufferedImage.TYPE_INT_ARGB);
 
 			Graphics2D gbi = horizTrailerBuffer.createGraphics();
 			gbi.setComposite(alphaComposite);
 
 			renderHorizontalTrailer(gbi);
 		}
 
 		return horizTrailerBuffer;
 	}
 
 	protected void calculateTrailerLocation()
 	{
 		int t = (int)(rangedValue.toRelative(getTrailerPosition()));
 
 		if(slider.getOrientation() == JSlider.HORIZONTAL) {
 			int valuePosition = xPositionForValue(t);
 
 			trailerRect.x = valuePosition - (trailerRect.width / 2);
 			trailerRect.y = thumbRect.y;
 		} else {
 			int valuePosition = yPositionForValue(t);
 
 			trailerRect.x = thumbRect.x;
 			trailerRect.y = valuePosition - (trailerRect.height / 2);
 		}
 	}
 
 	/**
 	 * Returns the position of the slider trailer.
 	 *
 	 * @return double
 	 */
 	public double getTrailerPosition()
 	{
 		return trailerPosition;
 	}
 
 	/**
 	 * Sets the slider trailer position.
 	 *
 	 * @param value new position
 	 */
 	public void setTrailerPosition(double value)
 	{
 		trailerCache.x = trailerRect.x;
 		trailerCache.y = trailerRect.y;
 				
 		trailerPosition = value;
 		calculateTrailerLocation();
 
 		//System.out.println(">>>> Ranged Value: " + rangedValue.getValue());
 		//System.out.println(">>>> Trailer Position: " + trailerPosition);
 		
 		boolean oldCheck = checkValue;
 
 		checkValue = (trailerPosition<=rangedValue.getMaximum() && trailerPosition>=rangedValue.getMinimum());
 
 		if (checkValue!=oldCheck) horizTrailerBuffer = null;
 
 		slider.repaint(trailerCache);
 		slider.repaint(trailerRect);
 		slider.repaint(new Rectangle(0, 0, slider.getWidth(), slider.getHeight()));
 	}
 
 	/**
 	 * Paints the trailer.
 	 *
 	 * @param g destination graphics
 	 */
 	public void paintTrailer(Graphics g)
 	{	
 		if (!paintTrailer) return;
 		g.translate(trailerRect.x, thumbRect.y);
 
 		if(slider.getOrientation() == JSlider.HORIZONTAL) {
 			((Graphics2D)g).drawImage(getTrailer(), null, 0, 0);
 		} else {
 		}
 
 		g.translate(-trailerRect.x, -thumbRect.y);
 
 		if(thumbRect.x == trailerRect.x) {
 			paintThumb(g);
 		}
 	}
 
 	protected Color[] getIndicatorColor()
 	{
 		if (slider.isEnabled()) {
 			if (paintTrailer) {
 				if (!checkValue) {
 					return RED_LED;
 				} else {
 					//retVal = (Math.abs(thumbRect.x - trailerRect.x) < 2) ? GREEN_LED : RED_LED;
 					return (Math.abs(rangedValue.getValue() - trailerPosition) < tolerance) ? GREEN_LED : RED_LED;
 				}
 			} else {
 				return GREEN_LED;
 			}
 		} else {
 			return GREY_LED;
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.plaf.metal.MetalSliderUI#paintThumb(java.awt.Graphics)
 	 */
 	public void paintThumb(Graphics g)
 	{
 		super.paintThumb(g);
 		
 		if (!paintTrailer) {
 			return;
 		}
 
 		Rectangle knobBounds = thumbRect;
 		g.translate(knobBounds.x, knobBounds.y);
 
 		if(slider.getOrientation() == JSlider.HORIZONTAL) {
 			Color[] colors = getIndicatorColor();
 
 			g.setColor(colors[0]);
 			g.drawLine(1, 3, 13, 3);
 			g.drawLine(13, 2, 13, 1);
 
 			g.setColor(colors[1]);
 			g.drawLine(1, 1, 13, 1);
 			g.drawLine(1, 1, 1, 3);
 			g.setColor(colors[2]);
 			g.drawLine(2, 2, 12, 2);
 			g.setColor(Color.black);
 			g.drawLine(1, 4, 13, 4);
 		} else {
 		}
 
 		g.translate(-knobBounds.x, -knobBounds.y);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.plaf.basic.BasicSliderUI#paint(java.awt.Graphics, javax.swing.JComponent)
 	 */
 	public void paint(Graphics g, JComponent c)
 	{
 		super.paint(g, c);
 		calculateTrailerLocation();
 
 		Rectangle clip = g.getClipBounds();
 
 		if(clip.intersects(trailerRect)) {
 			paintTrailer(g);
 		}
 
 		if(trailerRect.intersects(thumbRect)) {
 			paintThumb(g);
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.plaf.basic.BasicSliderUI#paintTicks(java.awt.Graphics)
 	 */
 	public void paintTicks(Graphics g)
 	{
 		final Rectangle tr = tickRect;
 		final Rectangle lr = labelRect;
 		int w = tr.width - 1;
 
 		g.setColor(slider.getBackground());
 		g.fillRect(tr.x, tr.y, tr.width, tr.height);
 
 		final Tick[] ticks = rangedValue.calculateTicks(w,new TickMeasurer(g, format));
 		
 		if(ticks == null) {
 			return;
 		}
 
 		g.translate(tr.x, tr.y-2);
 
 		final FontMetrics fm = g.getFontMetrics();
 		String text;
 		int left;
 		int x;
 		double tickValue;
 		for(int i = 0; i < ticks.length; i++) {
 			x = (int)(ticks[i].proportional * w);
 			if (showIntegerOnly) {
 				tickValue = ticks[i].absolute;
 				if(((long)(tickValue*1000L+0.5))/1000. !=  (long)(tickValue+0.5)) 
 					continue;
 //				else if (ticks[i].text != null && ticks[i].text.length() > 3){
 //					//ignore everything behind decimal separator
 //					ticks[i].text = ticks[i].text.substring(0, ticks[i].text.length()-2);
 //				}
 			}
 			
 			if(ticks[i].major) {
 				paintMajorTickForHorizSlider(g, tr, x);
 
 				text = ticks[i].text;
 				if(text==null) {
 					left = x;
 				} else {
 				    left = x - (fm.stringWidth(text) / 2);
 				}
 
 //				g.setColor(Color.BLACK);
 				g.setColor(slider.getForeground());
 				if(text!=null) {
 					g.drawString(text, left, lr.y - 8);
 				}
 			} else {
 				paintMinorTickForHorizSlider(g, tr, x);
 			}
 		}
 
 		g.translate(-tr.x, -tr.y+2);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.plaf.basic.BasicSliderUI#paintLabels(java.awt.Graphics)
 	 */
 	public void paintLabels(Graphics g)
 	{
 		paintTicks(g);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.plaf.metal.MetalSliderUI#scrollDueToClickInTrack(int)
 	 */
 	protected void scrollDueToClickInTrack(int dir)
 	{
 		// This has been disabled to prevent accidental value changes.
 		// super.scrollDueToClickInTrack(dir);
 	}
 	
 	/**
 	 * Sets the value display format.
 	 * 
 	 * @param format new format
 	 */
 	public void setFormat(String format) {
 		this.format = format;
 		if (format.contains("%d")) {
 			showIntegerOnly = true;
 		} else {
 			showIntegerOnly = false;
 		}
 	}
 	
 	/**
 	 * Sets the tolerance. This is the tolerance at which the thumb is considered
 	 * to be synchronized with the trailer.
 	 * 
 	 * @param tol new tolerance
 	 */
 	public void setTolerance(double tol) {
 		this.tolerance=tol;
 	}
 	
 	/**
 	 * Returns the tolerance.
 	 * 
 	 * @return
 	 */
 	public double getTolerance() {
 		return this.tolerance;
 	}
 	
 	/**
 	 * Sets the flag whether the trailer should be painted or not.
 	 * @param paint
 	 */
 	public void setPaintTrailer(boolean paint) {
 		this.paintTrailer = paint;
 		slider.repaint();
 	}
 	
 	/**
 	 * Returns a flag indicating whether the trailer is painted or not.
 	 * @return
 	 */
 	public boolean isPaintTrailer() {
 		return this.paintTrailer;
 	}
 
 	/**
 	 * Returns the format used by this ui to format the ticks.
 	 * @return
 	 */
 	public String getFormat() {
 		return format;
 	}
 }
 /* __oOo__ */