[Actionstep-commits] actionstep/src/org/actionstep ASDraw.as,1.4,1.5

[Richard K. <ric...@us...>]

Update of /cvsroot/actionstep/actionstep/src/org/actionstep
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31525

Added Files:
	ASDraw.as 
Log Message:
add her back in

--- NEW FILE: ASDraw.as ---
/*
 * Copyright (c) 2005, InfoEther, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, 
 * are permitted provided that the following conditions are met:
 * 
 * 1) Redistributions of source code must retain the above copyright notice, 
 *    this list of conditions and the following disclaimer.
 *  
 * 2) Redistributions in binary form must reproduce the above copyright notice, 
 *    this list of conditions and the following disclaimer in the documentation 
 *    and/or other materials provided with the distribution. 
 * 
 * 3) The name InfoEther, Inc. may not be used to endorse or promote products 
 *    derived from this software without specific prior written permission. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
 class org.actionstep.ASDraw {
  
  //draws a horizontal line with thickness=1.
  public static function drawHLine(mc:MovieClip, lineColor:Number, x1:Number, x2:Number, y1:Number) {
	 drawLine(mc, lineColor, x1, x2, y1, y1);
  }

  //draws a horizontal line with thickness=1.
  public static function drawVLine(mc:MovieClip, lineColor:Number, y1:Number, y2:Number, x1:Number) {
    if (y1 > y2) {
      var yTmp:Number = y1;
      y1 = y2;	   	
      y1 = yTmp;	   	
	  }	 
	  y2 += 1;
    drawLine(mc, lineColor, x1, x1, y1, y2);
  }

  //draws a horizontal line with thickness=1 and the edges fading out.
  public static function drawVLineEdgeFade(mc:MovieClip, lineColor:Number, y1:Number, y2:Number, x1:Number, edge:Number) {
	  if (y1 > y2) {
      var yTmp:Number = y1;
      y1 = y2;	   	
      y1 = yTmp;	   	
	  }	 
	  y2 += 1;
    drawLine(mc, lineColor, x1, x1, y1+edge, y2-edge);
    drawLineFade(mc, lineColor, x1, x1, y1+edge, y1);
    drawLineFade(mc, lineColor, x1, x1, y2-edge, y2);
  }

  //draws a horizontal line with thickness=1 and the edges fading out.
  public static function drawHLineEdgeFade(mc:MovieClip, lineColor:Number, x1:Number, x2:Number, y1:Number, edge:Number) {
	  if (x1 > x2) {
      var xTmp:Number = x1;
      x1 = x2;	   	
      x2 = xTmp;	   	
	  }	 
	  x2 += 1;
    drawLine(mc, lineColor, x1+edge, x2-edge, y1, y1);
    drawLineFade(mc, lineColor, x1+edge, x1, y1, y1);
    drawLineFade(mc, lineColor, x2-edge, x2, y1, y1);
  }

  public static function drawVLineFade(mc:MovieClip, lineColor:Number, y1:Number, y2:Number, x1:Number) {
    drawLineShared(mc, lineColor, true, x1, x1, y1, y2, 0);
  }

  public static function drawHLineFade(mc:MovieClip, lineColor:Number, x1:Number, x2:Number, y1:Number) {
    drawLineShared(mc, lineColor, true, y1, y1, x1, x2, 0);
  }

  public static function drawLineFade(mc:MovieClip, lineColor:Number, x1:Number, x2:Number, y1:Number, y2:Number) {
    drawLineShared(mc, lineColor, true, x1, x2, y1, y2, 0);
  }

  public static function drawLine(mc:MovieClip, lineColor:Number, x1:Number, x2:Number, y1:Number, y2:Number) {
    drawLineShared(mc, lineColor, false, x1, x2, y1, y2);
  }

  //draws a line with thickness=1.
  public static function drawLineShared(mc:MovieClip, lineColor:Number, isFade:Boolean, x1:Number, x2:Number, y1:Number, y2:Number) {
	  if (lineColor == undefined) {
	    return;
	  }
    var radians:Number = getRadians(x1, x2, y1, y2);
	  if (y1 > y2) {
      var yTmp:Number = y1;
      y1 = y2;	   	
      y2 = yTmp;	   	
	  }
	  //y2 += 1;
	  if (x1 > x2) {
      var xTmp:Number = x1;
      x1 = x2;	   	
      x2 = xTmp;	   	
	  }	 
	  //x2 += 1;
	  var w1:Number = x2 - x1 + 1;
	  var h1:Number = y2 - y1 + 1;
	  var xPlus:Number = 0;
	  var yPlus:Number = 0;
	  if (w1 == 1) {
      xPlus = 1;	
    }
	  if (h1 == 1) {
      yPlus = 1;	
    }
    mc.lineStyle(undefined, 0, 100);
    if (isFade) {
      var colors:Array = [lineColor,lineColor];
      var alphas:Array = [100,0];
      var ratios:Array = [0x0,0xFF];
      var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
      mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    } else {
      mc.beginFill(lineColor, 100);
    }

    mc.moveTo(x1,y1);
    mc.moveTo(x1+xPlus,y1+yPlus);
    mc.lineTo(x2+xPlus,y2+yPlus);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y1);
    mc.endFill();
  }

  /////////////////////////////////////////////////////////////////////////////
  // BOX METHODS
  /////////////////////////////////////////////////////////////////////////////

  //draws a rect with no border.
  public static function drawFill(mc:MovieClip, fillColor:Number, x1:Number, y1:Number, w1:Number, h1:Number) {
	  if (fillColor == undefined) 
	    return;
    mc.lineStyle(undefined, 0, 100);
    mc.beginFill(fillColor, 100);
    mc.moveTo(x1,y1);
    mc.lineTo(x1+w1, y1);
    mc.lineTo(x1+w1, y1+h1);
    mc.lineTo(x1, y1+h1);
    mc.lineTo(x1, y1);
    //mc.drawRect(x1, y1, w1, h1);
    mc.endFill();
  }

  // figure out how I wanna deal with the fact that these don't take w/h, but x1,x2,y1,y2
  public static function drawHBoxFade(mc:MovieClip, boxColor:Number, x1:Number, x2:Number, y1:Number, y2:Number) {
    drawBoxFade(mc, boxColor, x1, x2, y1, y2, 90);
  }

  public static function drawHBoxFade2(mc:MovieClip, boxColor:Number, boxColor2:Number, x1:Number, x2:Number, y1:Number, y2:Number) {
    drawBoxFade2(mc, boxColor, boxColor2, x1, x2, y1, y2, 90);
  }

  public static function drawBoxFade30(mc:MovieClip, boxColor, x1, x2, y1, y2) {
//		trace('drawBoxFade30: ' + x1 + ',' + x2 + ',' + y1 + ',' + y2);
	  var w1:Number = x2 - x1;
	  var h1:Number = y2 - y1;
    var colors:Array = [boxColor,boxColor,boxColor];
    var alphas:Array = [80,0,0];
//    var ratios = [0x0,0x33,0x66,0x99,0xCC,0xFF];
    var ratios:Array = [0x0,0x99,0xFF];
    var radians:Number = getRadiansByDegrees(45);
    var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
    mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    mc.moveTo(x1,y1);
    mc.lineTo(x2,y1);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y2);
    mc.lineTo(x1,y1);
    mc.endFill();
  }

  public static function drawBoxFade(mc:MovieClip, boxColor:Number, x1:Number, x2:Number, y1:Number, y2:Number, degrees:Number) {
	  var w1:Number = x2 - x1;
	  var h1:Number = y2 - y1;
//    var colors = [boxColor,boxColor];
//    var alphas = [100,0];
//    var ratios = [0x0,0xFF];
    var colors:Array = [boxColor,boxColor,boxColor];
    var alphas:Array = [100,50,0];
    var ratios:Array = [0x0,0x33,0xFF];
    var radians:Number = getRadiansByDegrees(degrees);
    var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
    mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    mc.moveTo(x1,y1);
    mc.lineTo(x2,y1);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y2);
    mc.lineTo(x1,y1);
    mc.endFill();
  }

  public static function drawBoxFade2(mc:MovieClip, boxColor:Number, boxColor2:Number, x1:Number, x2:Number, y1:Number, y2:Number, degrees:Number) {
	  var w1:Number = x2 - x1;
	  var h1:Number = y2 - y1;
    var colors:Array = [boxColor,boxColor2];
    var alphas:Array = [100,100];
    var ratios:Array = [0x0,0xFF];
    var radians:Number = getRadiansByDegrees(degrees);
    var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
    mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    mc.moveTo(x1,y1);
    mc.lineTo(x2,y1);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y2);
    mc.lineTo(x1,y1);
    mc.endFill();
  }
  

  //draws a rect 
  public static function drawRect(mc:MovieClip, thick:Number, color:Number, x1:Number, y1:Number, w1:Number, h1:Number) {
    if (color == undefined) 
      return;
    mc.lineStyle(thick, color, 100);
    mc.moveTo(x1,y1);
    mc.lineTo(x1+w1, y1);
    mc.lineTo(x1+w1, y1+h1);
    mc.lineTo(x1, y1+h1);
    mc.lineTo(x1, y1);
  }
  
  //      ------------------      DRAW CURVE      ------------------      //

  public static function drawCurve(mc:MovieClip, thick:Number, color:Number, startX:Number, startY:Number, curveControlX:Number,
                          curveControlY:Number,endX:Number,endY:Number)
  {
    mc.lineStyle(thick,color);
    mc.moveTo(startX,startY);
    mc.curveTo(curveControlX,curveControlY,endX,endY);
  }

  // draw Oval

  public static function drawOval(mc:MovieClip, thick:Number, color:Number, x:Number,y:Number, width:Number,height:Number){
    mc.lineStyle(thick, color);
    mc.moveTo(x,y+height/2);
    mc.curveTo(x,y,x+width/2, y);
    mc.curveTo(x+width,y,x+width, y+height/2);
    mc.curveTo(x+width,y+height, x+width/2, y+height);
    mc.curveTo(x,y+height, x, y+height/2);
  }

  // ---------    FILL OVAL       ------------    //

  public static function fillOval(mc:MovieClip, thick:Number, color:Number, fill:Number, x:Number,y:Number, width:Number,height:Number){
    mc.lineStyle(thick, color);
    mc.moveTo(x,y+height/2);
    mc.beginFill(fill);
    mc.curveTo(x,y,x+width/2, y);
    mc.curveTo(x+width,y,x+width, y+height/2);
    mc.curveTo(x+width,y+height, x+width/2, y+height);
    mc.curveTo(x,y+height, x, y+height/2);
    mc.endFill();
  }

  //      ---------       DRAW CIRCLE-----------  //

  public static function drawCircle(mc:MovieClip, thick:Number, color:Number, r:Number,x:Number,y:Number){
    var styleMaker:Number = 22.5;
    mc.moveTo(x+r,y);
    mc.lineStyle(thick, color);
    var style:Number = Math.tan(styleMaker*Math.PI/180);
    for (var angle:Number=45;angle<=360;angle+=45){
      var endX:Number = r * Math.cos(angle*Math.PI/180);
      var endY:Number = r * Math.sin(angle*Math.PI/180);
      var cX:Number   = endX + r* style * Math.cos((angle-90)*Math.PI/180);
      var cY:Number   = endY + r* style * Math.sin((angle-90)*Math.PI/180);
      mc.curveTo(cX+x,cY+y,endX+x,endY+y);
    }
  }

  // ---------    DRAW FILLED circle, ----------- //

  public static function fillCircle(mc:MovieClip, thick:Number, color:Number, fill:Number, r:Number,x:Number,y:Number){
    var styleMaker:Number = 22.5;
    mc.moveTo(x+r,y);
    mc.lineStyle(thick, color);
    mc.beginFill(fill)
    var style:Number = Math.tan(styleMaker*Math.PI/180);
    for (var angle:Number=45;angle<=360;angle+=45){
      var endX:Number = r * Math.cos(angle*Math.PI/180);
      var endY:Number = r * Math.sin(angle*Math.PI/180);
      var cX:Number   = endX + r* style * Math.cos((angle-90)*Math.PI/180);
      var cY:Number   = endY + r* style * Math.sin((angle-90)*Math.PI/180);
      mc.curveTo(cX+x,cY+y,endX+x,endY+y);
    }
    mc.endFill();
  }

  //      ---------       DRAW helix shape        -----------     //

  public static function drawHelix(mc:MovieClip, thick:Number, color:Number, r:Number,x:Number,y:Number,styleMaker:Number){
    mc.moveTo(x+r,y);
    mc.lineStyle(thick, color);
    var style:Number = Math.tan(styleMaker*Math.PI/180);
    for (var angle:Number=45;angle<=360;angle+=45){
      var endX:Number = r * Math.cos(angle*Math.PI/180);
      var endY:Number = r * Math.sin(angle*Math.PI/180);
      var cX:Number   = endX + r* style * Math.cos((angle-90)*Math.PI/180);
      var cY:Number   = endY + r* style * Math.sin((angle-90)*Math.PI/180);
      mc.curveTo(cX+x,cY+y,endX+x,endY+y);
    }
  }
  
  // ---------    DRAW FILLED helix SHAPE, -----------    //

  public static function fillHelix(mc:MovieClip, thick:Number, color:Number, fill:Number, r:Number,x:Number,y:Number,styleMaker:Number){
    mc.moveTo(x+r,y);
    mc.lineStyle(thick, color);
    mc.beginFill(fill)
    var style:Number = Math.tan(styleMaker*Math.PI/180);
    for (var angle:Number=45;angle<=360;angle+=45){
      var endX:Number = r * Math.cos(angle*Math.PI/180);
      var endY:Number = r * Math.sin(angle*Math.PI/180);
      var cX:Number   = endX + r* style * Math.cos((angle-90)*Math.PI/180);
      var cY:Number   = endY + r* style * Math.sin((angle-90)*Math.PI/180);
      mc.curveTo(cX+x,cY+y,endX+x,endY+y);
    }
    mc.endFill();
  }
  
  //      --------------  DRAW GRADIENT SHAPE     --------------  //      

  public static function drawGradientShape(mc:MovieClip, thick:Number, color:Number, r:Number,x:Number,y:Number,styleMaker:Number,
      col1:Number,col2:Number,fa1:Number,fa2:Number,
      matrixX:Number,matrixY:Number,matrixW:Number,
      matrixH:Number){
    mc.lineStyle(thick, color);
    mc.moveTo(x+r,y);
    var colors:Array = [col1 ,col2];
    var alphas:Array = [ fa1, fa2 ];
    var ratios:Array = [ 7, 0xFF ];
    var matrix:Object = { matrixType:"box", x:matrixX, 
      y:matrixY, w:matrixW, h:matrixH,
      r:(45/180)*Math.PI };
    mc.beginGradientFill( "linear", colors, alphas, ratios, matrix );
    var style:Number = Math.tan(styleMaker*Math.PI/180);
    for (var angle:Number=45;angle<=360;angle+=45){
      var endX:Number = r * Math.cos(angle*Math.PI/180);
      var endY:Number = r * Math.sin(angle*Math.PI/180);
      var cX:Number   = endX + r* style * Math.cos((angle-90)*Math.PI/180);
      var cY:Number   = endY + r* style * Math.sin((angle-90)*Math.PI/180);
      mc.curveTo(cX+x,cY+y,endX+x,endY+y);
    }
    mc.endFill();
  }

  //      -----------     GRADIENT RECTANGLE      -----------     //

  public static function gradientRect(mc:MovieClip, thick:Number, color:Number, x1:Number, y1:Number, width:Number, height:Number,
      col1:Number,col2:Number,fa1:Number,fa2:Number,
      matrixX:Number,matrixY:Number,matrixW:Number,
      matrixH:Number){
    mc.lineStyle(thick,color);
    var colors:Array = [col1 ,col2];
    var alphas:Array = [ fa1, fa2 ];
    var ratios:Array = [ 7, 0xFF ];
    var matrix:Object = { matrixType:"box", x:matrixX, y:matrixY,
      w:matrixW, h:matrixH, r:(45/180)*Math.PI };
    mc.moveTo(x1,y1);
    mc.beginGradientFill( "linear", colors, alphas, ratios, matrix );
    mc.lineTo(x1+width, y1);
    mc.lineTo(x1+width, y1+height);
    mc.lineTo(x1, y1+height);
    mc.lineTo(x1, y1);
    mc.endFill();
  }

  //      -----------             DRAW HEXAGON    ----------      //

  public static function drawHexagon(mc:MovieClip, thick:Number, color:Number, hexRadius:Number, startX, startY){
    var sideC:Number=hexRadius;
    var sideA:Number = 0.5 * sideC;
    var sideB:Number=Math.sqrt((hexRadius*hexRadius)
                                     - (0.5*hexRadius)* (0.5*hexRadius));
    mc.lineStyle(thick,color,100)
    mc.moveTo(startX,startY)
    mc.lineTo(startX,sideC+ startY);
    mc.lineTo(sideB+startX,startY+sideA+sideC);             // bottom point
    mc.lineTo(2*sideB + startX , startY + sideC);
    mc.lineTo(2*sideB + startX , startY);
    mc.lineTo(sideB + startX, startY - sideA);
    mc.lineTo(startX, startY);
  };


  public static function fillHexagon(mc:MovieClip, thick:Number, color:Number, fill:Number, hexRadius:Number, startX, startY){
    var sideC:Number=hexRadius;
    var sideA:Number = 0.5 * sideC;
    var sideB:Number=Math.sqrt((hexRadius*hexRadius) 
                                    - (0.5*hexRadius)* (0.5*hexRadius));
    mc.lineStyle(thick,color,100)
    mc.beginFill(fill);
    mc.moveTo(startX,startY)
    mc.lineTo(startX,sideC+ startY);
    mc.lineTo(sideB+startX,startY+sideA+sideC);             // bottom point
    mc.lineTo(2*sideB + startX , startY + sideC);
    mc.lineTo(2*sideB + startX , startY);
    mc.lineTo(sideB + startX, startY - sideA);
    mc.lineTo(startX, startY);
    mc.endFill();
  };  
  

/////////////////////////////////////////////////////////////////////////////
// GRADIENT METHODS
/////////////////////////////////////////////////////////////////////////////

  public static function drawExampleGradient(mc:MovieClip) {
	  drawTestLineGradient(mc, 50, 100, 50, 250);
  }

  public static function drawTestLineGradient(mc:MovieClip, x1:Number, x2:Number, y1:Number, y2:Number) {
	  var w1:Number = x2 - x1;
	  var h1:Number = y2 - y1;
	 //trace("x1=" + x1 + ",x2=" + x2 + "y1=" + y1 + ",y2=" + y2 + "w1=" + w1 + ",h1=" + h1)
    var colors:Array = [0xFF0000,0xFFFF00,0x00FF00,0x00FFFF,0x0000FF,0xFF00FF];
    var alphas:Array = [100,100,100,100,100,100];
    var ratios:Array = [0x0,0x33,0x66,0x99,0xCC,0xFF];
    var radians:Number = getRadians(x1, x2, y1, y2);
    var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
    mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    mc.lineStyle(undefined, 0, 100);
    mc.moveTo(x1,y1);
    mc.moveTo(x1+1,y1+1);
    mc.lineTo(x2+1,y2+1);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y1);
    mc.endFill();
  }
/*
  public static function drawTestGradient(mc:MovieClip, x1:Number, x2:Number, y1:Number, y2:Number) {
	  var w1:Number = x2 - x1;
	  var h1:Number = y2 - y1;
    // EXAMPLE GRADIENT
    var colors:Array = [0xFF0000,0xFFFF00,0x00FF00,0x00FFFF,0x0000FF,0xFF00FF];
    // all of the colors should be opaque
    var alphas:Array = [100,100,100,100,100,100];
    // these ratios are in hexadeciaml, in even steps from 0 to 255
    var ratios:Array = [0x0,0x33,0x66,0x99,0xCC,0xFF];
    // 0 radians is the equivalent of no rotation for the gradient
//    var radians = getRadiansByDegrees(0);
    var radians:Number = getRadians(x1, x2, y1, y2);
    // build our matrix using the "box" method
    var matrix = { matrixType:"box", x:x1, y:y1, w:w1, h:h1, r: radians }
    // put all that together in the beginGradientFill
    mc.beginGradientFill("linear",colors,alphas,ratios,matrix);
    // draw the bounding box
    mc.moveTo(x1,y1);
    mc.lineTo(x2,y1);
    mc.lineTo(x2,y2);
    mc.lineTo(x1,y2);
    mc.lineTo(x1,y1);
    // close up the fill
    mc.endFill();
    drawLine(mc, lineColor, x1, x2, y1, y2);
  }*/
  
  
  public static function drawRoundedRect(mc, x, y, w, h, cornerRadius) {
  	// ==============
  	// mc.drawRect() - by Ric Ewing (ri...@fo...) - version 1.1 - 4.7.2002
  	// 
  	// x, y = top left corner of rect
  	// w = width of rect
  	// h = height of rect
  	// cornerRadius = [optional] radius of rounding for corners (defaults to 0)
  	// ==============
  	if (arguments.length<4) {
  		return;
  	}
  	// if the user has defined cornerRadius our task is a bit more complex. :)
  	if (cornerRadius>0) {
  		// init vars
  		var theta, angle, cx, cy, px, py;
  		// make sure that w + h are larger than 2*cornerRadius
  		if (cornerRadius>Math.min(w, h)/2) {
  			cornerRadius = Math.min(w, h)/2;
  		}
  		// theta = 45 degrees in radians
  		theta = Math.PI/4;
  		// draw top line
  		mc.moveTo(x+cornerRadius, y);
  		mc.lineTo(x+w-cornerRadius, y);
  		//angle is currently 90 degrees
  		angle = -Math.PI/2;
  		// draw tr corner in two parts
  		cx = x+w-cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+w-cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		angle += theta;
  		cx = x+w-cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+w-cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		// draw right line
  		mc.lineTo(x+w, y+h-cornerRadius);
  		// draw br corner
  		angle += theta;
  		cx = x+w-cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+h-cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+w-cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+h-cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		angle += theta;
  		cx = x+w-cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+h-cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+w-cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+h-cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		// draw bottom line
  		mc.lineTo(x+cornerRadius, y+h);
  		// draw bl corner
  		angle += theta;
  		cx = x+cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+h-cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+h-cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		angle += theta;
  		cx = x+cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+h-cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+h-cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		// draw left line
  		mc.lineTo(x, y+cornerRadius);
  		// draw tl corner
  		angle += theta;
  		cx = x+cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  		angle += theta;
  		cx = x+cornerRadius+(Math.cos(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		cy = y+cornerRadius+(Math.sin(angle+(theta/2))*cornerRadius/Math.cos(theta/2));
  		px = x+cornerRadius+(Math.cos(angle+theta)*cornerRadius);
  		py = y+cornerRadius+(Math.sin(angle+theta)*cornerRadius);
  		mc.curveTo(cx, cy, px, py);
  	} else {
  		// cornerRadius was not defined or = 0. This makes it easy.
  		mc.moveTo(x, y);
  		mc.lineTo(x+w, y);
  		mc.lineTo(x+w, y+h);
  		mc.lineTo(x, y+h);
  		mc.lineTo(x, y);
  	}
  }


  /////////////////////////////////////////////////////////////////////////////
  // RADIAN METHODS
  /////////////////////////////////////////////////////////////////////////////

  public static function getRadiansByDegrees(degrees:Number):Number {
    // To calculate a radian value, use this formula:
    // radian = Math.PI/180 * degree
    return Math.PI/180 * degrees;
  }

  public static function getRadians(x1:Number, x2:Number, y1:Number, y2:Number):Number {
	  var x_base   = x2-x1;
	  var y_height = y2-y1;
	  if (x_base == 0) {
  		if (y_height > 0) {
   	    return getRadiansByDegrees(90);
   	  }
      return getRadiansByDegrees(270);
	  }
	  if (y_height == 0) {
		  if (x_base > 0) {
        return getRadiansByDegrees(180);
      }
 	    return getRadiansByDegrees(0);
	  }
    // The return value represents the opposite angle of a right triangle in radians
    // where x is the adjacent side length and y is the opposite side length.
    return Math.atan2(  x_base, y_height  ) 
  }

  public static function getAngleAdjacentRadians(base:Number, height:Number):Number {
    // The return value represents the opposite angle of a right triangle in radians
    // where x is the adjacent side length and y is the opposite side length.
    return Math.atan2(  height, base  ) 
  }

  public static function getAngleOppositeRadians(base:Number, height:Number):Number {
    // The return value represents the opposite angle of a right triangle in radians
    // where x is the adjacent side length and y is the opposite side length.
    return Math.atan2(  base, height  ) 
  }
}