/*
    * 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 com.cosylab.gui.components.gauger.ScaleTransform.ArcSegment;
  import com.cosylab.gui.components.gauger.ScaleTransform.RectangleSegment;
  import com.cosylab.gui.components.range2.Tick;
  //import com.cosylab.gui.components.range.Tick;
  
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.FontMetrics;
  import java.awt.Graphics2D;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.geom.Arc2D;
  import java.awt.geom.Ellipse2D;
  import java.awt.geom.Line2D;
  import java.awt.geom.Point2D;
  
  
  /**
   * ScaleTransformRenderer renders the gauger component defined by ScaleTransform.
   * This class is responsible for interpreting the transform and rendering
   * background, scale and ticks. Renderer will render custom defined
   * scale segments.
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @version $id$
   */
  public class ScaleTransformRenderer
  {
  	private Gauger gauger;
  	private ScaleTransform transform;
  
  	/**
  	 * Creates a new ScaleTransformRenderer object.
  	 *
  	 * @param gauger Gauger which this transform will render.
  	 */
  	public ScaleTransformRenderer(Gauger gauger)
  	{
  		super();
  		this.gauger = gauger;
  	}
  
  	/**
  	 * Renders background of gauger. Fills the area with background color of
  	 * gauger.
  	 *
  	 * @param g Context to render to.
  	 */
  	public void renderBackground(Graphics2D g)
  	{
  		g.setColor(gauger.getBackground());
  
  		g.fillRect(0, 0, gauger.getWidth(), gauger.getHeight());
  	}
  
  	protected void renderRectangleSegment(Graphics2D g,
  	    ScaleTransform.RectangleSegment segment, int n, int i)
  	{
  		Rectangle r = segment.rect;
  
  		int x1 = r.x;
  		int x2 = r.x + r.width;
  		int y1 = r.y;
  		int y2 = r.y + r.height;
  
  		g.fillRect(x1, y1, r.width, r.height);
  
  		g.setColor(Color.black);
  
  		g.drawLine(x1, y1, x2, y1);
  		g.drawLine(x1 + 1, y1 + 1, x2 - 1, y1 + 1);
  
  		if(i == 0) {
  			g.drawLine(x1, y1 + 1, x1, y2);
  			g.drawLine(x1 + 1, y1 + 1, x1 + 1, y2 - 1);
  		}
  
 		g.setColor(Color.white);
 
 		g.drawLine(x1 + 1, y2, x2, y2);
 		g.drawLine(x1 + 2, y2 - 1, x2, y2 - 1);
 
 		if(i == n - 1) {
 			g.drawLine(x2, y1 + 1, x2, y2);
 			g.drawLine(x2 - 1, y1 + 2, x2, y2);
 		}
 	}
 
 	/**
 	 * Renders scale. Renders individual scale segments.
 	 *
 	 * @param g Graphic context to render to.
 	 */
 	public void renderScale(Graphics2D g)
 	{
 		ScaleTransform.ScaleSegment segment;
 
 		int n = transform.getSegmentCount();
 
 		g.setColor(gauger.getScaleColor());
 
 		for(int i = 0; i < n; i++) {
 			segment = transform.getSegment(i);
 
 			if(segment instanceof ScaleTransform.RectangleSegment) {
 				renderRectangleSegment(g, (RectangleSegment)segment, n, i);
 			}
 
 			if(segment instanceof ScaleTransform.ArcSegment) {
 				renderArcSegment(g, (ArcSegment)segment, n, i);
 			}
 		}
 	}
 
 	/**
 	 * Renders borders and background of an arc segment. 
 	 *
 	 * @param g Graphic context to render to.
 	 * @param segment Segment to render.
 	 * @param n Total number of segments.
 	 * @param i Current segment index.
 	 */
 	public void renderArcSegment(Graphics2D g, ArcSegment segment, int n, int i)
 	{
 		double r = segment.rInner;
 		double R = segment.rOuter;
 
 		Point p1 = new Point();
 		Point p2 = new Point();
 
 		g.translate(segment.center.getX(), segment.center.getY());
 
 		Arc2D arc = new Arc2D.Double();
 
 		g.setColor(gauger.getScaleColor());
 
 		arc.setArcType(Arc2D.PIE);
 
 		arc.setFrame(-R, -R, 2 * R, 2 * R);
 		arc.setAngleStart(segment.startAngle);
 		arc.setAngleExtent(-segment.arcAngle);
 		g.fill(arc);
 
 		arc.setArcType(Arc2D.PIE);
 		
 		g.setColor(gauger.getBackground());
 		arc.setFrame(-r, -r, 2 * r, 2 * r);
 		arc.setAngleStart(segment.startAngle);
 		arc.setAngleExtent(-segment.arcAngle);
 		g.fill(arc);
 
 		Ellipse2D circle = new Ellipse2D.Double();
 
 		g.setColor(gauger.getBackground());
 
 		circle.setFrame(-r, -r, 2 * r, 2 * r);
 		g.fill(circle);
 
 		arc.setArcType(Arc2D.OPEN);
 
 		g.setColor(Color.WHITE);
 		arc.setFrame(-r, -r, 2 * r, 2 * r);
 		arc.setAngleStart(segment.startAngle+0.03);
 		arc.setAngleExtent(-segment.arcAngle-0.03);
 		g.draw(arc);
 
 		BasicStroke s = new BasicStroke((float)2.0);
 		g.setStroke(s);
 
 		if(i == n - 1) {
 			double phi = segment.startAngle - segment.arcAngle;
 			PolarPoint.polarToCartesian(p1, r, phi);
 			PolarPoint.polarToCartesian(p2, R, phi);
 
 			g.drawLine(p1.x, p1.y, p2.x, p2.y);
 		}
 
 		g.setColor(Color.BLACK);
 
 		if(i == 0) {
 			PolarPoint.polarToCartesian(p1, r, segment.startAngle);
 			PolarPoint.polarToCartesian(p2, R, segment.startAngle);
 
 			g.drawLine(p1.x, p1.y, p2.x, p2.y);
 		}
 
 		g.setColor(Color.BLACK);
 
 		arc.setFrame(-R - 1, -R - 1, 2 * R + 2, 2 * R + 2);
 		arc.setAngleStart(segment.startAngle);
 		arc.setAngleExtent(-segment.arcAngle + 0.03);
 
 		g.draw(arc);
 
 		g.translate(-segment.center.getX(), -segment.center.getY());
 	}
 
 	/**
 	 * Renders ticks and tick labels.
 	 *
 	 * @param g Graphic context to render to.
 	 */
 	public void renderTicks(Graphics2D g)
 	{
 		//Tick[] ticks=null; /* edit apikus */
 		Tick[] ticks = gauger.getTicks(); 
 
 		if((ticks == null) || (ticks.length < 2)) {
 			return;
 		}
 
 		final FontMetrics metrics = g.getFontMetrics();
 		Tick tick;
 		double xOfs;
 		double phi;
 		final int n = ticks.length;
 
 		g.setStroke(new BasicStroke(1.0f));
 		g.setColor(Color.black);
 		g.setFont(gauger.getTickTextFont());
 
 		Line2D line = new Line2D.Double();
 
 		Point2D p1 = transform.mapUVtoXY(0.5, 0);
 //		Point2D p2 = transform.mapUVtoXY(0.5, 10000.0);
 		//xOfs = -p1.distance(p2) * 0.0001;
 		xOfs = -transform.scaleHeight(0.5);
 		double mult = 1.0;
 		if (Math.abs(xOfs) < 2*metrics.getHeight()) {
 			mult = 0.5;
 		}
 
 		final float textOffs = (float)(xOfs * 0.6*mult);
 		final double minorOffs = xOfs * 0.25*mult;
 		final double majorOffs = xOfs * 0.5 *mult;
 
 		for(int i = 0; i < n; i++) {
 			tick = ticks[i];
 
 			transform.mapUVtoXY(tick.proportional, 0.0, p1);
 
 			phi = transform.getAngle(tick.proportional);
 
 			g.translate(p1.getX(), p1.getY());
 			g.rotate(-phi);
 
 			if(tick.major) {
 				line.setLine(0, 0, 0, majorOffs);
 
 				xOfs = -metrics.getStringBounds(tick.text, g).getCenterX();
 
 				g.drawString(tick.text, (float)xOfs, textOffs);
 			} else {
 				line.setLine(0, 0, 0, minorOffs);
 			}
 
 			g.draw(line);
 
 			g.rotate(phi);
 			g.translate(-p1.getX(), -p1.getY());
 		}
 	}
 
 	/**
 	 * Render entire gauger.
 	 *
 	 * @param transform Transform used for rendering.
 	 * @param g Graphic context to render to.
 	 */
 	public void render(ScaleTransform transform, Graphics2D g)
 	{
 		this.transform = transform;
 		renderBackground(g);
 		renderScale(g);
 		renderTicks(g);
 	}
 }
 
 /* __oOo__ */