/*
    * 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.gauger;
  
  import com.cosylab.gui.components.Gauger;
  
  import java.awt.Color;
  import java.awt.Graphics2D;
  import java.awt.Point;
  import java.awt.Polygon;
  import java.awt.Rectangle;
  
  
  /**
   * Component defining and rendering the needle.
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @version $id$
   */
  public class Needle implements ActiveElement
  {
  	/* Scale appearance */
  
  	/** Relative length of needle as fraction of scale space height */
  	private final static double RELATIVE_NEEDLE_SIZE = 0.6;
  	//private static final int DISTANCE_SIGNIFICANT_CHANGE = 2;
  	//private static final double ANGLE_SIGNIFICANT_CHANGE = 10;
  	//private static final int DEFAULT_SIZE = 15;
  	//private static final double DEFAULT_ANGLE = 90;
  	private static final double DEFAULT_RATIO = 7.0;
  	private Gauger gauger;
  	private boolean changeSignificant;
  	private Point p;
  	private double angle;
  	private Rectangle bounds = new Rectangle(0, 0, 0, 0);
  	private double currentPosition = 0.5;
  	protected ScaleTransform transform = null;
  	private double[] xValues = new double[3];
  	private double[] yValues = new double[3];
  	private Polygon poly = new Polygon(new int[3], new int[3], 3);
  	private boolean outOfBounds=false;
  	
  	/**
  	 * Needle constructor comment.
  	 *
  	 * @param gauger on which the needle will be rendered.
  	 */
  	public Needle(Gauger gauger)
  	{
  		p = new Point();
  		angle = 0;
  		this.gauger = gauger;
  		changeSignificant = true;
  	}
  
  	/**
  	 * Updates the polygon representation of the needle.
  	 */
  	protected synchronized void calculatePolygon()
  	{
  		double sin = Math.sin(angle);
  		double cos = Math.cos(angle);
  
  		for(int i = 0; i < xValues.length; i++) {
  			double xi = xValues[i];
  			double yi = yValues[i];
  			poly.xpoints[i] = (int)(xi * sin - yi * cos + p.x);
  			poly.ypoints[i] = (int)(xi * cos + yi * sin + p.y);
  		}
  
  		poly.invalidate();
  
  		bounds = poly.getBounds();
  		bounds.grow(3, 3);
  	}
  
  	private synchronized final void invalidate()
  	{
  		double size = transform.scaleHeight(0.5) * RELATIVE_NEEDLE_SIZE;
  		double s = (size / DEFAULT_RATIO);
  		yValues[0] = -s;
  		xValues[0] = 0;
 
 		yValues[1] = 0;
 		xValues[1] = -size;
 
 		yValues[2] = s;
 		xValues[2] = 0;
 	}
 
 	/**
 	 * Returns bounding rectangle of needle.
 	 *
 	 * @return Bounding rectangle of needle.
 	 */
 	public Rectangle getBounds()
 	{
 		return bounds;
 	}
 
 	/**
 	 * Returns true if needle has moved enough to require immediate redraw.
 	 *
 	 * @return True if needle should be redrawn immediatelly.
 	 */
 	public boolean isChangeSignificant()
 	{
 		return changeSignificant;
 	}
 
 	protected void updatePosition(double x)
 	{
 		if((transform != null)) {
 			changeSignificant = true;
 
 		//checkChangeSignificant(tempPoint1.x, tempPoint1.y, phi);
 			if(changeSignificant) {
 				transform.mapUVtoXY(x, 0, p);
 
 				angle = transform.getAngle(x);
 				calculatePolygon();
 			}
 		}
 	}
 
 	/**
 	 * Sets position of needle in scale space coordinates. Value is relative
 	 * position between 0.0 and 1.0 inclusively.
 	 *
 	 * @param proportionalPosition New position of needle.
 	 */
 	public void setPosition(double proportionalPosition)
 	{
 		updatePosition(proportionalPosition);
 
 		if(changeSignificant) {
 			currentPosition = proportionalPosition;
 		}
 	}
 
 	/**
 	 * Renders needle.
 	 *
 	 * @see ActiveElement#render(Graphics2D)
 	 */
 	public synchronized void render(Graphics2D g)
 	{
 	
 		double position = (gauger.getValue()-gauger.getMinimum())/(gauger.getMaximum() - gauger.getMinimum());
 
 		if(outOfBounds == ( (position < 0) || (position>1.0) )) {
 			g.setColor(gauger.getOutOfBoundsColor());
 		} else if( (position <= gauger.getLowAlarmLimit()) || (position>=gauger.getHighAlarmLimit()) ){
 			g.setColor(gauger.getAlarmColor());
 		} else if( (position <= gauger.getLowWarningLimit()) || (position>=gauger.getHighWarningLimit()) ){ 
 			g.setColor(gauger.getWarningColor());
 		} else{
 			g.setColor(gauger.getNeedleColor());
 		}
 		
 		g.fillPolygon(poly);
 		g.drawPolygon(poly);
 
 		g.setColor(Color.BLACK);
 
 		g.drawLine(poly.xpoints[0], poly.ypoints[0], poly.xpoints[1],
 		    poly.ypoints[1]);
 	}
 
 	/**
 	 * Sets transform defining the gauger. This transform is used to render the
 	 * needle at appropriate position and angle.
 	 *
 	 * @see ActiveElement#setTransform(ScaleTransform)
 	 */
 	public void setTransform(ScaleTransform transform)
 	{
 		this.transform = transform;
 		invalidate();
 		updatePosition(currentPosition);
 	}
 	
 	/**
 	 * NOT IMPLEMENTED!
 	 * Returns true if value is out of bounds.
 	 * 
 	 * @return
 	 */
 	public boolean isOutOfBounds(){
 		return outOfBounds;
 	}
 }
 
 /* __oOo__ */