RoundedRectangle.java

package org.newdawn.slick.geom;

import java.util.ArrayList;
import java.util.List;

import org.newdawn.slick.util.FastTrig;

/**
 * Class to create rounded rectangles with.
 * 
 * @author Mark Bernard
 */
public class RoundedRectangle extends Rectangle {
	/** Indicates the top left corner should be rounded */
	public static final int TOP_LEFT  = 1;
	/** Indicates the top right corner should be rounded */
	public static final int TOP_RIGHT = 2; 
	/** Indicates the bottom right corner should be rounded */
	public static final int BOTTOM_RIGHT = 4;
	/** Indicates the bottom left corner should be rounded */
	public static final int BOTTOM_LEFT = 8;
	/** Indicates the all cornders should be rounded */
	public static final int ALL = TOP_LEFT | TOP_RIGHT | BOTTOM_RIGHT | BOTTOM_LEFT;
	
    /** Default number of segments to draw the rounded corners with */
    private static final int DEFAULT_SEGMENT_COUNT = 25;

    /** radius of each corner */
    private float cornerRadius;
    /** number of segments for each corner */
    private int segmentCount;
    /** The flags indicating which corners should be rounded */
    private int cornerFlags;
    
    /**
     * Construct a rectangle with rounded corners.
     * 
     * @param x The x position of the rectangle.
     * @param y The y position of the rectangle.
     * @param width The width of the rectangle.
     * @param height The hieght of the rectangle.
     * @param cornerRadius The radius to use for the arc in each corner.
     */
    public RoundedRectangle(float x, float y, float width, float height, float cornerRadius) {
        this(x, y, width, height, cornerRadius, DEFAULT_SEGMENT_COUNT);
    }

    /**
     * Construct a rectangle with rounded corners.
     * 
     * @param x The x position of the rectangle.
     * @param y The y position of the rectangle.
     * @param width The width of the rectangle.
     * @param height The hieght of the rectangle.
     * @param cornerRadius The radius to use for the arc in each corner.
     * @param segmentCount The number of segments to use to draw each corner arc.
     */
    public RoundedRectangle(float x, float y, float width, float height, float cornerRadius, int segmentCount) {
    	this(x,y,width,height,cornerRadius,segmentCount,ALL);
    }
    	
    /**
     * Construct a rectangle with rounded corners.
     * 
     * @param x The x position of the rectangle.
     * @param y The y position of the rectangle.
     * @param width The width of the rectangle.
     * @param height The hieght of the rectangle.
     * @param cornerRadius The radius to use for the arc in each corner.
     * @param segmentCount The number of segments to use to draw each corner arc.
     * @param cornerFlags Indicates which corners should be rounded 
     */
    public RoundedRectangle(float x, float y, float width, float height, 
    						float cornerRadius, int segmentCount, int cornerFlags) {
        super(x,y,width,height);
        
    	if(cornerRadius < 0) {
            throw new IllegalArgumentException("corner radius must be >= 0");
        }
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        this.cornerRadius = cornerRadius;
        this.segmentCount = segmentCount;
        this.pointsDirty = true;
        this.cornerFlags = cornerFlags;
    }

    /**
     * Get the radius for each corner.
     * 
     * @return The radius for each corner.
     */
    public float getCornerRadius() {
        return cornerRadius;
    }

    /**
     * Set the radius for each corner.
     * 
     * @param cornerRadius The radius for each corner to set.
     */
    public void setCornerRadius(float cornerRadius) {
        if (cornerRadius >= 0) {
        	if (cornerRadius != this.cornerRadius) {
	            this.cornerRadius = cornerRadius;
	            pointsDirty = true;
        	}
        }
    }

    /**
     * Get the height of this rectangle.
     * 
     * @return The height of this rectangle.
     */
    public float getHeight() {
        return height;
    }

    /**
     * Set the height of this rectangle.
     * 
     * @param height The height to set.
     */
    public void setHeight(float height) {
    	if (this.height != height) {
	        this.height = height;
	        pointsDirty = true;
    	}
    }

    /**
     * Get the width of this rectangle.
     * 
     * @return The width of this rectangle.
     */
    public float getWidth() {
        return width;
    }

    /**
     * Set the width of this rectangle.
     * 
     * @param width The width to set.
     */
    public void setWidth(float width) {
    	if (width != this.width) {
	        this.width = width;
	        pointsDirty = true;
    	}
    }

    protected void createPoints() {
        maxX = x + width;
        maxY = y + height;
        minX = x;
        minY = y;
        float useWidth = width - 1;
        float useHeight = height - 1;
        if(cornerRadius == 0) {
            points = new float[8];
            
            points[0] = x;
            points[1] = y;
            
            points[2] = x + useWidth;
            points[3] = y;
            
            points[4] = x + useWidth;
            points[5] = y + useHeight;
            
            points[6] = x;
            points[7] = y + useHeight;
        }
        else {
            float doubleRadius = cornerRadius * 2;
            if(doubleRadius > useWidth) {
                doubleRadius = useWidth;
                cornerRadius = doubleRadius / 2;
            }
            if(doubleRadius > useHeight) {
                doubleRadius = useHeight;
                cornerRadius = doubleRadius / 2;
            }
            
            ArrayList tempPoints = new ArrayList();
            //the outer most set of points for each arc will also ac as the points that start the
            //straight sides, so the straight sides do not have to be added.
            
            //top left corner arc
            if ((cornerFlags & TOP_LEFT) != 0) {
            	tempPoints.addAll(createPoints(segmentCount, cornerRadius, x + cornerRadius, y + cornerRadius, 180, 270));
            } else {
            	tempPoints.add(new Float(x));
            	tempPoints.add(new Float(y));
            }
            
            //top right corner arc
            if ((cornerFlags & TOP_RIGHT) != 0) {
            	tempPoints.addAll(createPoints(segmentCount, cornerRadius, x + useWidth - cornerRadius, y + cornerRadius, 270, 360));
            } else {
            	tempPoints.add(new Float(x+useWidth));
            	tempPoints.add(new Float(y));
            }
            
            //bottom right corner arc
            if ((cornerFlags & BOTTOM_RIGHT) != 0) {
            	tempPoints.addAll(createPoints(segmentCount, cornerRadius, x + useWidth - cornerRadius, y + useHeight - cornerRadius, 0, 90));
            } else {
            	tempPoints.add(new Float(x+useWidth));
            	tempPoints.add(new Float(y+useHeight));
            }
            
            //bottom left corner arc
            if ((cornerFlags & BOTTOM_LEFT) != 0) {
	            tempPoints.addAll(createPoints(segmentCount, cornerRadius, x + cornerRadius, y + useHeight - cornerRadius, 90, 180));
	        } else {
	        	tempPoints.add(new Float(x));
	        	tempPoints.add(new Float(y+useHeight));
	        }
            
            points = new float[tempPoints.size()];
            for(int i=0;i<tempPoints.size();i++) {
                points[i] = ((Float)tempPoints.get(i)).floatValue();
            }
        }
        
        findCenter();
        calculateRadius();
    }

    /**
     * Generate the points to fill a corner arc.
     *
     * @param numberOfSegments How fine to make the ellipse.
     * @param radius The radius of the arc.
     * @param cx The x center of the arc.
     * @param cy The y center of the arc.
     * @param start The start angle of the arc.
     * @param end The end angle of the arc.
     * @return The points created.
     */
    private List createPoints(int numberOfSegments, float radius, float cx, float cy, float start, float end) {
        ArrayList tempPoints = new ArrayList();

        int step = 360 / numberOfSegments;
        
        for (float a=start;a<=end+step;a+=step) {
            float ang = a;
            if (ang > end) {
                ang = end;
            }
            float x = (float) (cx + (FastTrig.cos(Math.toRadians(ang)) * radius));
            float y = (float) (cy + (FastTrig.sin(Math.toRadians(ang)) * radius));
            
            tempPoints.add(new Float(x));
            tempPoints.add(new Float(y));
        }
        
        return tempPoints;
    }
    /**
     * Apply a transformation and return a new shape.  This will not alter the current shape but will 
     * return the transformed shape.
     * 
     * @param transform The transform to be applied
     * @return The transformed shape.
     */
    public Shape transform(Transform transform) {
        checkPoints();
        
        Polygon resultPolygon = new Polygon();
        
        float result[] = new float[points.length];
        transform.transform(points, 0, result, 0, points.length / 2);
        resultPolygon.points = result;
        resultPolygon.findCenter();

        return resultPolygon;
    }
    
}