/*
 * ArrowManager.java
 *
 * Created on May 5, 2006, 10:53 AM
 */

package org.pat.graphics.arrows;

import java.awt.*;
import java.awt.geom.*;

/**
 *
 * @author  pat
 */
public class ArrowManager {
    // handles the scaling factor of the arrow
    private double scale=1;
    private AffineTransform scaler;
    
    /** Set to have forward or backward pointing arrows.
     * Set to true to display arrows in the corresponding directions. */
    public boolean forward=false, backward=false;
    
    /** Set the arrow style used */
    public ArrowStyle forward_style, backward_style;
    
    /** Creates a new instance of ArrowManager */
    public ArrowManager() {
        forward=false;
        backward=false;
        setScaler();
    }
    
    /** set backward arrow style to style */
    public void setBackwardArrowStyle(ArrowStyle style) {
        forward_style=style;
    }
    
    /** set the forward arrow style to style */
    public void setForwardArrowStyle(ArrowStyle style) {
        forward_style=style;
    }
    
    /** set both the forward arrow style and the backward arrow style to style */
    public void setArrowStyle(ArrowStyle style) {
        forward_style=style;
        backward_style=style;
    }
    
    public double getScaleFactor() {
        return scale;
    }
    
    public void setScaleFactor(double scale_factor) {
        scale=scale_factor;
    }
    
    public void scaleBy(double factor) {
        scale*=factor;
    }
    
    private void setScaler() {
        scaler=AffineTransform.getScaleInstance(scale,scale);
    }
    
    /** get an arrow at location with in direction determined by angle
     * in the style of the forward arrow */
    public Shape getArrowHead(Point2D location, double angle) {
        return getArrowHead(location, angle, true);
    }
    
    public Shape getArrowHead(Point2D location, double angle, boolean forward) {
        AffineTransform t=new AffineTransform(scaler);
        t.rotate(angle);
        t.translate(location.getX(),location.getY());
        if (forward) {
            return t.createTransformedShape(forward_style.standardArrow());
        }
        return t.createTransformedShape(backward_style.standardArrow());
    }
    
    public void renderArrow(Graphics2D g, AffineTransform transform,
    Point2D start, Point2D end, boolean forward){
        AffineTransform t=new AffineTransform(transform);
        t.translate(end.getX(),end.getY());
        t.rotate(Math.atan2(end.getY()-start.getY(), end.getX()-start.getX()));
        double s=scale/Math.sqrt(Math.abs(transform.getDeterminant()));        
        t.scale(s,s);
        if (forward) {
            g.draw(t.createTransformedShape(forward_style.standardArrow()));
        } else {
            g.draw(t.createTransformedShape(backward_style.standardArrow()));
        }
    }
}