java.args=-Xmx384m -Dsun.io.useCanonCaches=false

java.args=-Xmx512m -Dsun.io.useCanonCaches=false

package labs.otuome.ui.renderers
{
  import mx.controls.Button;
  import mx.controls.advancedDataGridClasses.AdvancedDataGridHeaderRenderer;
 
  /**
   * Custom header renderer for displaying 
   * a graphical image in the column header.
   * @author Hasan Otuome
   */
  public class StatusHeaderRenderer extends AdvancedDataGridHeaderRenderer
  {                                                                                          
    /////////////////////////////////////////////////////////////////////////////////////////
    // PRIVATE PROPERTIES                                                                    
    /////////////////////////////////////////////////////////////////////////////////////////
    private var _btn:Button;                                                                 
    private const LEFT_PADDING:int = 12;                                                     
    /////////////////////////////////////////////////////////////////////////////////////////
    // PUBLIC PROPERTIES                                                                     
    /////////////////////////////////////////////////////////////////////////////////////////
 
    /////////////////////////////////////////////////////////////////////////////////////////
    // PUBLIC METHODS                                                                        
    /////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Constructor 
     */		
    public function StatusHeaderRenderer()
    {
      super();
    }
 
    /////////////////////////////////////////////////////////////////////////////////////////
    // OVERRIDES
    /////////////////////////////////////////////////////////////////////////////////////////
    /**
     * Override to add the custom component. 
     */		
    override protected function createChildren():void
    {
      super.createChildren();
 
      _btn = new Button();
      _btn.width = 16;
      _btn.height = 16;
      _btn.setStyle( 'skin', StatusMarkerHeaderIconSkin );
 
      addChild( _btn );
    }
    /**
     * Override to layout the children 
     * @param unscaledWidth
     * @param unscaledHeight
     */		
    override protected function updateDisplayList( unscaledWidth:Number, 
                                                  unscaledHeight:Number ):void
    {
      _btn.x = LEFT_PADDING;
 
      super.updateDisplayList( unscaledWidth, unscaledHeight );
    }
    /////////////////////////////////////////////////////////////////////////////////////////
    // PRIVATE METHODS
    /////////////////////////////////////////////////////////////////////////////////////////
  }
}

import mx.core.ClassFactory; 
myADGColumn.headerRenderer = new ClassFactory( StatusHeaderRenderer );

/**
 * Draws a double-headed arrow. Pass in ArrowStyle
 * objects for both arrows to override the default settings.
 * @param graphics
 * @param start
 * @param end
 * @param startStyle
 * @param endStyle
 */
public static function drawArrows( graphics:Graphics,
        start:Point,end:Point,
        startStyle:Object=null,
        endStyle:Object=null ):void
{
	// variables used for arrow 1
	var startArrowStyle:ArrowStyle;
	var startHalfWidth:Number;
	var vect1:Point;
	var startNorm:Point;
	var start1:Point;
	var start2:Point;
	var end1:Point;
	var end2:Point;
	var startHeadPnt:Point;
	var startHeadPntNorm:Point;
	var startEdge1:Point;
	var startEdge2:Point;
	var startShaftCenter:Point;
	var startInter1:Point;
	var startInter2:Point;
	var startEdgeCenter:Point;
	var startEdgeNorm:Point;
	var startEdgeCntrl1:Point;
	var startEdgeCntrl2:Point;
 
	// variables used for arrow 2
	var endArrowStyle:ArrowStyle;
	var endHalfWidth:Number;
	var vect2:Point;
	var endNorm:Point;
	var end3:Point;
	var end4:Point;
	var start3:Point;
	var start4:Point;
	var endHeadPnt:Point;
	var endHeadPntNorm:Point;
	var endEdge1:Point;
	var endEdge2:Point;
	var endShaftCenter:Point;
	var endInter1:Point;
	var endInter2:Point;
	var endEdgeCenter:Point;
	var endEdgeNorm:Point;
	var endEdgeCntrl1:Point;
	var endEdgeCntrl2:Point;
 
	if (start.equals(end)) return;
 
	///////////////////////////////// start arrow config \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
	if (startStyle == null)
	{
		startArrowStyle = new ArrowStyle();
	}
	else if (startStyle is ArrowStyle)
	{
		startArrowStyle = startStyle as ArrowStyle;
	}
	else
	{
		startArrowStyle = new ArrowStyle( startStyle );
	}
 
	vect1 = end.subtract( start );
	startHalfWidth = (startArrowStyle.headWidth != -1) ? startArrowStyle.headWidth / 2 : startArrowStyle.headLength / 2; 
 
	//Figure out the line start/end points
	startNorm = new Point( vect1.y, -vect1.x );
	startNorm.normalize( startArrowStyle.shaftThickness/ 2 );
	start1 = start.add( startNorm );
	start2 = start.subtract( startNorm );
	end1 = end.add( startNorm );
	end2 = end.subtract( startNorm );
 
	//figure out where the arrow head starts
	startHeadPnt = vect1.clone();
	startHeadPnt.normalize( startHeadPnt.length - startArrowStyle.headLength );
	startHeadPnt = startHeadPnt.add( start );
 
	//calculate the arrowhead corners
	startHeadPntNorm = startNorm.clone();
	startHeadPntNorm.normalize( startHalfWidth );
	startEdge1 = startHeadPnt.add( startHeadPntNorm );
	startEdge2 = startHeadPnt.subtract( startHeadPntNorm );
 
	//Figure out where the arrow connects the the shaft, then calc the intersections
	startShaftCenter = Point.interpolate( end, startHeadPnt, startArrowStyle.shaftPosition );
	startInter1 = GeomUtil.getLineIntersection( start1, end1, startShaftCenter, startEdge1 );
	startInter2 = GeomUtil.getLineIntersection( start2, end2, startShaftCenter, startEdge2 );
 
	//Figure out the control points
	startEdgeCenter = Point.interpolate( end, startHeadPnt, startArrowStyle.edgeControlPosition );
	startEdgeNorm = startNorm.clone();
	startEdgeNorm.normalize( startHalfWidth * startArrowStyle.edgeControlSize );
	startEdgeCntrl1 = startEdgeCenter.add( startEdgeNorm );
	startEdgeCntrl2 = startEdgeCenter.subtract( startEdgeNorm );
 
	///////////////////////////////// end arrow config \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
	if (endStyle == null)
	{
		endArrowStyle = new ArrowStyle();
	}
	else if (endStyle is ArrowStyle)
	{
		endArrowStyle = endStyle as ArrowStyle;
	}
	else
	{
		endArrowStyle = new ArrowStyle( endStyle );
	}
 
	vect2 = start.subtract( end );
	endHalfWidth = (endArrowStyle.headWidth != -1) ? endArrowStyle.headWidth / 2 : endArrowStyle.headLength / 2;
 
	//Figure out the line start/end points
	endNorm = new Point( vect2.y, -vect2.x );
	endNorm.normalize( endArrowStyle.shaftThickness / 2 );
	start3 = start.add( endNorm );
	start4 = start.subtract( endNorm );
	end3 = end.add( endNorm );
	end4 = end.subtract( endNorm );
 
	//figure out where the arrow head starts
	endHeadPnt = vect2.clone();
	endHeadPnt.normalize( endHeadPnt.length - endArrowStyle.headLength );
	endHeadPnt = endHeadPnt.add( end );
 
	//calculate the arrowhead corners
	endHeadPntNorm = endNorm.clone();
	endHeadPntNorm.normalize( endHalfWidth );
	endEdge1 = endHeadPnt.add( endHeadPntNorm );
	endEdge2 = endHeadPnt.subtract( endHeadPntNorm );
 
	//Figure out where the arrow connects the the shaft, then calc the intersections
	endShaftCenter = Point.interpolate( start, endHeadPnt, endArrowStyle.shaftPosition );
	endInter1 = GeomUtil.getLineIntersection( end3, start3, endShaftCenter, endEdge1 );
	endInter2 = GeomUtil.getLineIntersection( end4, start4, endShaftCenter, endEdge2 );
 
	//Figure out the control points
	endEdgeCenter = Point.interpolate( start, endHeadPnt, endArrowStyle.edgeControlPosition );
	endEdgeNorm = endNorm.clone();
	endEdgeNorm.normalize( endHalfWidth * endArrowStyle.edgeControlSize );
	endEdgeCntrl1 = endEdgeCenter.add( endEdgeNorm );
	endEdgeCntrl2 = endEdgeCenter.subtract( endEdgeNorm );
 
	///////////////////////////////// draw the graphics \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
	// draw 1st arrow
	graphics.moveTo( start1.x, start2.y );
	graphics.lineTo( startInter1.x, startInter1.y );
	graphics.lineTo( startEdge1.x, startEdge1.y );
	graphics.curveTo( startEdgeCntrl1.x, startEdgeCntrl1.y, end.x, end.y );
	graphics.curveTo( startEdgeCntrl2.x, startEdgeCntrl2.y, startEdge2.x, startEdge2.y );
	graphics.lineTo( startInter2.x, startInter2.y );
	graphics.lineTo( start2.x, start2.y );
	graphics.lineTo( start1.x, start1.y );
 
	// draw 2nd arrow
	graphics.moveTo( end3.x, end4.y );
	graphics.lineTo( endInter1.x, endInter1.y );
	graphics.lineTo( endEdge1.x, endEdge1.y );
	graphics.curveTo( endEdgeCntrl1.x, endEdgeCntrl1.y, start.x, start.y );
	graphics.curveTo( endEdgeCntrl2.x, endEdgeCntrl2.y, endEdge2.x, endEdge2.y );
	graphics.lineTo( endInter2.x, endInter2.y );
	graphics.lineTo( end4.x, end4.y );
	graphics.lineTo( end3.x, end3.y );
}

/flex_sdk_3.x_air_sdk_2.x/AIR20_mac_sdk_120209.tbz2

tar -xjf AIR20_mac_sdk_120209.tbz2

<application xmlns="http://ns.adobe.com/air/application/2.0beta">

/**
 * Draws the gradient background for 
 * this component on initialize and resize.
 */	
private function _createGradientBackground():void
{
   var fillType:String      = GradientType.LINEAR;
   var colors:Array         = [ 0xe9e9e9, 0xc7c7c7 ];
   var alphas:Array         = [ 1, 1 ];
   var ratios:Array         = [ 0, 255 ];
   var matrix:Matrix        = new Matrix();
       matrix.createGradientBox( width, 34, Math.PI/2, 0, 0 );
   var spreadMethod:String 	= SpreadMethod.PAD;
   var g:Graphics           = this.graphics;
       g.clear();
       g.beginGradientFill( fillType, colors, alphas, ratios, matrix, spreadMethod );
       g.drawRect( 0, 0, width, height );
       g.endFill();
}

package labs.otuome.fl.graphics
{
	import flash.display.GradientType;
	import flash.display.Graphics;
	import flash.display.SpreadMethod;
	import flash.display.Sprite;
	import flash.geom.Matrix;
 
	/**
	 * Util class to create linear gradient fills.
	 * @author Hasan Otuome
	 */
	public class LinearGradientUtil
	{
		///////////////////////////////////////////////////////////////////////////////////////////////
		// PRIVATE PROPERTIES
		///////////////////////////////////////////////////////////////////////////////////////////////
 
		///////////////////////////////////////////////////////////////////////////////////////////////
		// PUBLIC PROPERTIES
		///////////////////////////////////////////////////////////////////////////////////////////////
		public static const HORIZONTAL:String 		= 'horizontalLinearGradient';
		public static const VERTICAL:String 		= 'verticalLinearGradient';
		///////////////////////////////////////////////////////////////////////////////////////////////
		// PUBLIC METHODS
		///////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 * Draws the linear gradient to the .graphics 
		 * property of the specified component. Defaults 
		 * to a Web 2.0 style gray gradient.
		 * 
		 * @param target The display object to apply the gradient to.
		 * @param size For a vertical gradient this is the 
		 * height of the gradient. For a horizontal gradient, 
		 * this is the width of the gradient. 
		 * @param primaryColor The top or left-most color depending on orientation.
		 * @param secondaryColor The bottom or right-most color depending on orientation.
		 * @param primaryAlpha The top or left-most color depending on orientation.
		 * @param secondaryAlpha The bottom or right-most alpha depending on orientation.
		 * @param primaryRatio The ratio of the top or left-most color depending on orientation.
		 * @param secondaryRatio The ratio of the bottom or right-most color depending on orientation.
		 * @param orientation either horizontal or vertical. defaults to vertical.
		 * @param invert Toggle that switches what the method considers primary and secondary.
		 */		
		public static function createGradientBackground( target:Sprite, 
						size:uint=34, 
						cornerRadius:uint=0, 
						primaryColor:uint=0xe9e9e9, 
						secondaryColor:uint=0xc7c7c7, 
						primaryAlpha:uint=1, 
						secondaryAlpha:uint=1, 
						primaryRatio:uint=0, 
						secondaryRatio:uint=255, 
						orientation:String=LinearGradientUtil.HORIZONTAL, 
						invert:Boolean=false ):void
		{
			var fillType:String;
			var colors:Array;
			var alphas:Array;
			var ratios:Array;
			var matrix:Matrix;
			var spreadMethod:String;
			var g:Graphics;
 
			fillType 			= GradientType.LINEAR;
			colors 				= _createColorsArray( primaryColor, secondaryColor, invert );
			alphas 				= _createAlphasArray( primaryAlpha, secondaryAlpha, invert );
			ratios 				= _createRatiosArray( primaryRatio, secondaryRatio, invert );
			matrix 				= new Matrix();
 
			switch (orientation)
			{
				case LinearGradientUtil.HORIZONTAL:
					matrix.createGradientBox( size, target.height, Math.PI/2, 0, 0 );
					break;
				case LinearGradientUtil.VERTICAL:
					matrix.createGradientBox( target.width, size, Math.PI/2, 0, 0 );
					break;
			}
 
			spreadMethod 		= SpreadMethod.PAD;
 
			g 					= target.graphics;
			g.clear();
			g.beginGradientFill( fillType, colors, alphas, ratios, matrix, spreadMethod );
 
			if (cornerRadius > 0)
			{
				g.drawRoundRect( 0, 0, target.width, target.height, cornerRadius );
			}
			else
			{
				g.drawRect( 0, 0, target.width, target.height );
			}
 
			g.endFill();
		}
		///////////////////////////////////////////////////////////////////////////////////////////////
		// OVERRIDES
		///////////////////////////////////////////////////////////////////////////////////////////////
 
		///////////////////////////////////////////////////////////////////////////////////////////////
		// PRIVATE METHODS
		///////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 * Creates the colors array required by the main method. 
		 * @param colorOne
		 * @param colorTwo
		 * @param inverted
		 * @return The gradient colors array.
		 */		
		private static function _createColorsArray( colorOne:uint, 
						colorTwo:uint, 
						inverted:Boolean=false ):Array
		{
			var colors:Array;
			if (!inverted)
			{
				colors = [ colorOne, colorTwo ]; 
			}
			else
			{
				colors = [ colorTwo, colorOne ]; 
			}
			return colors;
		}
		/**
		 * Creates the alphas array required by the main method. 
		 * @param colorOneAlpha
		 * @param colorTwoAlpha
		 * @param inverted
		 * @return The gradient alphas array.
		 */		
		private static function _createAlphasArray( colorOneAlpha:uint, 
						colorTwoAlpha:uint, 
						inverted:Boolean=false ):Array
		{
			var alphas:Array;
			if (!inverted)
			{
				alphas = [ colorOneAlpha, colorTwoAlpha ]; 
			}
			else
			{
				alphas = [ colorTwoAlpha, colorOneAlpha ]; 
			}
			return alphas;
		}
		/**
		 * Creates the ratios array required by the main method. 
		 * @param colorOneRatio
		 * @param colorTwoRatio
		 * @param inverted
		 * @return The gradient ratios array.
		 */		
		private static function _createRatiosArray( colorOneRatio:uint, 
						colorTwoRatio:uint, 
						inverted:Boolean=false ):Array
		{
			var ratios:Array;
			if (!inverted)
			{
				ratios = [ colorOneRatio, colorTwoRatio ]; 
			}
			else
			{
				ratios = [ colorTwoRatio, colorOneRatio ]; 
			}
			return ratios;
		}
	}
}

/**
 * Draws the gradient background for 
 * this component on initialize and resize.
 */	
private function _createGradientBackground():void
{
//	LinearGradientUtil.createGradientBackground( this, this.height, getStyle('cornerRadius'), 0xfdfeff, 0xe9e9e9 ); // changing color scheme
//	LinearGradientUtil.createGradientBackground( this ); // using the default color scheme
}