import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import javax.swing.JComponent;

/**
 *  A component that paints the outline of a Shape object. Click detection will
 *  be determined by the Shape itself, not the bounding Rectangle of the Shape.
 *
 *  Shape objects can be created with an X/Y offset. These offsets will
 *  be ignored and the Shape outline will always be painted at (0, 0) so the
 *  outline is fully contained within the component.
 */
public class OutlineComponent extends JComponent
{
	private Shape shape;
	private int thickness = 1;
	private boolean antiAliasing = true;

	private BasicStroke stroke;
	private Rectangle strokeBounds;

	/**
	 *  Create a OutlineComponent with a 1 pixel BLACK outline
	 *
	 *  @param shape the shape to be painted
	 */
	public OutlineComponent(Shape shape)
	{
		this(shape, Color.BLACK, 1);
	}

	/**
	 *  Create a OutlineComponent with a 1 pixel outline painted in the
	 *  specified color
	 *
	 *  @param shape the shape to be painted
	 *  @param color the outline color of the shape
	 */
	public OutlineComponent(Shape shape, Color color)
	{
		this(shape, color, 1);
	}

	/**
	 *  Create a OutlineComponent with a BLACK outline painted at the
	 *  specified thickness
	 *
	 *  @param shape the shape to be painted
	 *  @param thickness the thickness of the outline
	 */
	public OutlineComponent(Shape shape, int thickness)
	{
		this(shape, Color.BLACK, thickness);
	}

	/**
	 *  Create a OutlineComponent with the outline painted in the specified
	 *  color and thickness
	 *
	 *  @param shape the Shape outline to be painted
	 *  @param color the color of the outline
	 *  @param thicknes the thickness of the outline
	 */
	public OutlineComponent(Shape shape, Color color, int thickness)
	{
		setShape( shape );
		setForeground( color );
		setThickness( thickness );

		setOpaque( false );
	}

	/**
	 *  Get the Shape of the component
	 *
	 *  @returns the the Shape of the compnent
	 */
	public Shape getShape()
	{
		return shape;
	}

	/**
	 *  Set the Shape for this component
	 *
	 *  @param shape the Shape of the component
	 */
	public void setShape(Shape shape)
	{
		this.shape = shape;
		resetStroke();
		revalidate();
		repaint();
	}

	/**
	 *	Get the thickness of the Shape outline when painted
	 *
	 *  @return the Shape outline thickness
	 */
	public int getThickness()
	{
		return thickness;
	}

	/**
	 *  Set the Shape outline thickness
	 *
	 *  @param thickness the Shape outline in pixels
	 */
	public void setThickness(int thickness)
	{
		this.thickness = thickness;
		resetStroke();
		revalidate();
		repaint();
	}

	/**
	 *  Use AntiAliasing when painting the shape
	 *
	 *  @returns true for AntiAliasing false otherwise
	 */
	public boolean isAntiAliasing()
	{
		return antiAliasing;
	}

	/**
	 *  Set AntiAliasing property for painting the Shape
	 *
	 *  @param antiAliasing true for AntiAliasing, false otherwise
	 */
	public void setAntiAliasing(boolean antiAliasing)
	{
		this.antiAliasing = antiAliasing;
		revalidate();
		repaint();
	}

	private void resetStroke()
	{
		stroke = new BasicStroke( thickness );
		strokeBounds = stroke.createStrokedShape(shape).getBounds();
	}

    /**
     * {@inheritDoc}
     */
	@Override
	public Dimension getPreferredSize()
	{
		//  Include Border insets and Shape bounds

		Insets insets = getInsets();
		int adjustment = getAdjustment();

		//  Determine the preferred size

		int width = insets.left + insets.right + strokeBounds.width + adjustment;
		int height = insets.top + insets.bottom + strokeBounds.height + adjustment;

		return new Dimension(width, height);
	}

	private int getAdjustment()
	{
		//  For odd thicknesses

		if (thickness % 2 == 1)
			return -1;

		//  For even thicknesses we also need to check for anti aliasing

		return (isAntiAliasing()) ? 1 : 0;
	}

    /**
     * {@inheritDoc}
     */
	@Override
	public Dimension getMinimumSize()
	{
		return getPreferredSize();
	}

    /**
     * {@inheritDoc}
     */
	@Override
	public Dimension getMaximumSize()
	{
		return getPreferredSize();
	}

	@Override
	protected void paintComponent(Graphics g)
	{
		super.paintComponent(g);

		//  Graphics2D is required for antialiasing and painting Shapes

		Graphics2D g2d = (Graphics2D)g.create();

		if (isAntiAliasing())
	        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

		//  The draw() method will paint the Shape outline (up/left) of the
		//  filled Shape. Since we want all the painting to be done at a zero
		//  offset we must manully translate the Shape (down/right) before it
		//  is painted.

		int shift = getShift();

		//  Shape translation (ie. non-zero X/Y position in bounding rectangle)
		//  and Border insets.

		Insets insets = getInsets();

		//  Do all translations at once

		int translateX = insets.left - strokeBounds.x + shift;
		int translateY = insets.top - strokeBounds.y + shift;
		g2d.translate(translateX, translateY);

		//  Draw the Shape with the specified Color and thickness

		g2d.setStroke( stroke );
		g2d.setColor( getForeground());
		g2d.draw( shape );

		g2d.dispose();
	}

    /**
     *  This method will only determine if the point is in the bounds of the
     *  Shape. The outline of the Shape as painted by the draw() method
     *  is not considered part of the Shape.
     *
     * {@inheritDoc}
     */
	@Override
	public boolean contains(int x, int y)
	{
		Insets insets = getInsets();
		int shift = getShift();

		//  Check to see if the Shape contains the point. Take into account
		//  the Shape X/Y coordinates, Border insets and Shape translation.

		int translateX = x + strokeBounds.x - insets.left;
		int translateY = y + strokeBounds.y - insets.top;

		return shape.contains(translateX, translateY);
	}

	/**
	 *  The painting of the Shape outline may be shifted depending on the
	 *  stroke thickness. The painting is shifted to make sure it starts
	 *  at the top/left of the component.
	 */
	private int getShift()
	{
		int shift = (thickness % 2 == 0) ? 0 : -1;
		return shift;
	}
}