////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////

package mx.utils
{

import flash.display.Graphics;

/**
 *  The Graphics class is an all-static class with utility methods
 *  related to the Graphics class.
 *  You do not create instances of GraphicsUtil;
 *  instead you simply call methods such as the
 *  <code>GraphicsUtil.drawRoundRectComplex()</code> method.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */
public class GraphicsUtil
{
	include "../core/Version.as";

	//--------------------------------------------------------------------------
	//
	//  Class methods
	//
	//--------------------------------------------------------------------------
    
    /**
     * Draws a rounded rectangle using the size of a radius to draw the rounded corners. 
     * You must set the line style, fill, or both 
     * on the Graphics object before 
     * you call the <code>drawRoundRectComplex()</code> method 
     * by calling the <code>linestyle()</code>, 
     * <code>lineGradientStyle()</code>, <code>beginFill()</code>, 
     * <code>beginGradientFill()</code>, or 
     * <code>beginBitmapFill()</code> method.
     * 
     * @param graphics The Graphics object that draws the rounded rectangle.
     *
     * @param x The horizontal position relative to the 
     * registration point of the parent display object, in pixels.
     * 
     * @param y The vertical position relative to the 
     * registration point of the parent display object, in pixels.
     * 
     * @param width The width of the round rectangle, in pixels.
     * 
     * @param height The height of the round rectangle, in pixels.
     * 
     * @param topLeftRadius The radius of the upper-left corner, in pixels.
     * 
     * @param topRightRadius The radius of the upper-right corner, in pixels.
     * 
     * @param bottomLeftRadius The radius of the bottom-left corner, in pixels.
     * 
     * @param bottomRightRadius The radius of the bottom-right corner, in pixels.
     *
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public static function drawRoundRectComplex(graphics:Graphics, x:Number, y:Number, 
                                                width:Number, height:Number, 
                                                topLeftRadius:Number, topRightRadius:Number, 
                                                bottomLeftRadius:Number, bottomRightRadius:Number):void
    {
        var xw:Number = x + width;
        var yh:Number = y + height;
        
        // Make sure none of the radius values are greater than w/h.
        // These are all inlined to avoid function calling overhead
        var minSize:Number = width < height ? width * 2 : height * 2;
        topLeftRadius = topLeftRadius < minSize ? topLeftRadius : minSize;
        topRightRadius = topRightRadius < minSize ? topRightRadius : minSize;
        bottomLeftRadius = bottomLeftRadius < minSize ? bottomLeftRadius : minSize;
        bottomRightRadius = bottomRightRadius < minSize ? bottomRightRadius : minSize;
        
        // Math.sin and Math,tan values for optimal performance.
        // Math.rad = Math.PI / 180 = 0.0174532925199433
        // r * Math.sin(45 * Math.rad) =  (r * 0.707106781186547);
        // r * Math.tan(22.5 * Math.rad) = (r * 0.414213562373095);
        //
        // We can save further cycles by precalculating
        // 1.0 - 0.707106781186547 = 0.292893218813453 and
        // 1.0 - 0.414213562373095 = 0.585786437626905
        
        // bottom-right corner
        var a:Number = bottomRightRadius * 0.292893218813453;		// radius - anchor pt;
        var s:Number = bottomRightRadius * 0.585786437626905; 	// radius - control pt;
        graphics.moveTo(xw, yh - bottomRightRadius);
        graphics.curveTo(xw, yh - s, xw - a, yh - a);
        graphics.curveTo(xw - s, yh, xw - bottomRightRadius, yh);
        
        // bottom-left corner
        a = bottomLeftRadius * 0.292893218813453;
        s = bottomLeftRadius * 0.585786437626905;
        graphics.lineTo(x + bottomLeftRadius, yh);
        graphics.curveTo(x + s, yh, x + a, yh - a);
        graphics.curveTo(x, yh - s, x, yh - bottomLeftRadius);
        
        // top-left corner
        a = topLeftRadius * 0.292893218813453;
        s = topLeftRadius * 0.585786437626905;
        graphics.lineTo(x, y + topLeftRadius);
        graphics.curveTo(x, y + s, x + a, y + a);
        graphics.curveTo(x + s, y, x + topLeftRadius, y);
        
        // top-right corner
        a = topRightRadius * 0.292893218813453;
        s = topRightRadius * 0.585786437626905;
        graphics.lineTo(xw - topRightRadius, y);
        graphics.curveTo(xw - s, y, xw - a, y + a);
        graphics.curveTo(xw, y + s, xw, y + topRightRadius);
        graphics.lineTo(xw, yh - bottomRightRadius);
    }
    
    /**
     * Draws a rounded rectangle using the size of individual x and y radii to 
     * draw the rounded corners. 
     * You must set the line style, fill, or both 
     * on the Graphics object before 
     * you call the <code>drawRoundRectComplex2()</code> method 
     * by calling the <code>linestyle()</code>, 
     * <code>lineGradientStyle()</code>, <code>beginFill()</code>, 
     * <code>beginGradientFill()</code>, or 
     * <code>beginBitmapFill()</code> method.
     * 
     * @param graphics The Graphics object that draws the rounded rectangle.
     *
     * @param x The horizontal position relative to the 
     * registration point of the parent display object, in pixels.
     * 
     * @param y The vertical position relative to the 
     * registration point of the parent display object, in pixels.
     * 
     * @param width The width of the round rectangle, in pixels.
     * 
     * @param height The height of the round rectangle, in pixels.
     * 
     * @param radiusX The default radiusX to use, if corner-specific values are not specified.
     * This value must be specified.
     * 
     * @param radiusY The default radiusY to use, if corner-specific values are not specified. 
     * If 0, the value of radiusX is used.
     * 
     * @param topLeftRadiusX The x radius of the upper-left corner, in pixels. If NaN, 
     * the value of radiusX is used.
     * 
     * @param topLeftRadiusY The y radius of the upper-left corner, in pixels. If NaN,
     * the value of topLeftRadiusX is used.
     * 
     * @param topRightRadiusX The x radius of the upper-right corner, in pixels. If NaN,
     * the value of radiusX is used.
     * 
     * @param topRightRadiusY The y radius of the upper-right corner, in pixels. If NaN,
     * the value of topRightRadiusX is used.
     * 
     * @param bottomLeftRadiusX The x radius of the bottom-left corner, in pixels. If NaN,
     * the value of radiusX is used.
     * 
     * @param bottomLeftRadiusY The y radius of the bottom-left corner, in pixels. If NaN,
     * the value of bottomLeftRadiusX is used.
     * 
     * @param bottomRightRadiusX The x radius of the bottom-right corner, in pixels. If NaN,
     * the value of radiusX is used.
     * 
     * @param bottomRightRadiusY The y radius of the bottom-right corner, in pixels. If NaN,
     * the value of bottomRightRadiusX is used.
     * 
     *  
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5
     *  @productversion Flex 4
     */
    public static function drawRoundRectComplex2(graphics:Graphics, x:Number, y:Number, 
                                                width:Number, height:Number, 
                                                radiusX:Number, radiusY:Number,
                                                topLeftRadiusX:Number, topLeftRadiusY:Number,
                                                topRightRadiusX:Number, topRightRadiusY:Number,
                                                bottomLeftRadiusX:Number, bottomLeftRadiusY:Number,
                                                bottomRightRadiusX:Number, bottomRightRadiusY:Number):void
    {
        var xw:Number = x + width;
        var yh:Number = y + height;
        var maxXRadius:Number = width / 2;
        var maxYRadius:Number = height / 2;
        
        // Rules for determining radius for each corner:
        //  - If explicit nnnRadiusX value is set, use it. Otherwise use radiusX.
        //  - If explicit nnnRadiusY value is set, use it. Otherwise use corresponding nnnRadiusX.
        if (radiusY == 0)
            radiusY = radiusX;
        if (isNaN(topLeftRadiusX))
            topLeftRadiusX = radiusX;
        if (isNaN(topLeftRadiusY))
            topLeftRadiusY = topLeftRadiusX;
        if (isNaN(topRightRadiusX))
            topRightRadiusX = radiusX;
        if (isNaN(topRightRadiusY))
            topRightRadiusY = topRightRadiusX;
        if (isNaN(bottomLeftRadiusX))
            bottomLeftRadiusX = radiusX;
        if (isNaN(bottomLeftRadiusY))
            bottomLeftRadiusY = bottomLeftRadiusX;
        if (isNaN(bottomRightRadiusX))
            bottomRightRadiusX = radiusX;
        if (isNaN(bottomRightRadiusY))
            bottomRightRadiusY = bottomRightRadiusX;
        
        // Pin radius values to half of the width/height
        if (topLeftRadiusX > maxXRadius)
            topLeftRadiusX = maxXRadius;
        if (topLeftRadiusY > maxYRadius)
            topLeftRadiusY = maxYRadius;
        if (topRightRadiusX > maxXRadius)
            topRightRadiusX = maxXRadius;
        if (topRightRadiusY > maxYRadius)
            topRightRadiusY = maxYRadius;
        if (bottomLeftRadiusX > maxXRadius)
            bottomLeftRadiusX = maxXRadius;
        if (bottomLeftRadiusY > maxYRadius)
            bottomLeftRadiusY = maxYRadius;
        if (bottomRightRadiusX > maxXRadius)
            bottomRightRadiusX = maxXRadius;
        if (bottomRightRadiusY > maxYRadius)
            bottomRightRadiusY = maxYRadius;
        
        // Math.sin and Math,tan values for optimal performance.
        // Math.rad = Math.PI / 180 = 0.0174532925199433
        // r * Math.sin(45 * Math.rad) =  (r * 0.707106781186547);
        // r * Math.tan(22.5 * Math.rad) = (r * 0.414213562373095);
        //
        // We can save further cycles by precalculating
        // 1.0 - 0.707106781186547 = 0.292893218813453 and
        // 1.0 - 0.414213562373095 = 0.585786437626905
        
        // bottom-right corner
        var aX:Number = bottomRightRadiusX * 0.292893218813453;		// radius - anchor pt;
        var aY:Number = bottomRightRadiusY * 0.292893218813453;		// radius - anchor pt;
        var sX:Number = bottomRightRadiusX * 0.585786437626905; 	// radius - control pt;
        var sY:Number = bottomRightRadiusY * 0.585786437626905; 	// radius - control pt;
        graphics.moveTo(xw, yh - bottomRightRadiusY);
        graphics.curveTo(xw, yh - sY, xw - aX, yh - aY);
        graphics.curveTo(xw - sX, yh, xw - bottomRightRadiusX, yh);
        
        // bottom-left corner
        aX = bottomLeftRadiusX * 0.292893218813453;
        aY = bottomLeftRadiusY * 0.292893218813453;
        sX = bottomLeftRadiusX * 0.585786437626905;
        sY = bottomLeftRadiusY * 0.585786437626905;
        graphics.lineTo(x + bottomLeftRadiusX, yh);
        graphics.curveTo(x + sX, yh, x + aX, yh - aY);
        graphics.curveTo(x, yh - sY, x, yh - bottomLeftRadiusY);
        
        // top-left corner
        aX = topLeftRadiusX * 0.292893218813453;
        aY = topLeftRadiusY * 0.292893218813453;
        sX = topLeftRadiusX * 0.585786437626905;
        sY = topLeftRadiusY * 0.585786437626905;
        graphics.lineTo(x, y + topLeftRadiusY);
        graphics.curveTo(x, y + sY, x + aX, y + aY);
        graphics.curveTo(x + sX, y, x + topLeftRadiusX, y);
        
        // top-right corner
        aX = topRightRadiusX * 0.292893218813453;
        aY = topRightRadiusY * 0.292893218813453;
        sX = topRightRadiusX * 0.585786437626905;
        sY = topRightRadiusY * 0.585786437626905;
        graphics.lineTo(xw - topRightRadiusX, y);
        graphics.curveTo(xw - sX, y, xw - aX, y + aY);
        graphics.curveTo(xw, y + sY, xw, y + topRightRadiusY);
        graphics.lineTo(xw, yh - bottomRightRadiusY);
    }
}

}