package labs.otuome.air.myapp.view.panel
{
   import flash.display.NativeWindow;
   import flash.events.Event;
   import flash.events.NativeWindowDisplayStateEvent;
 
   public interface OwnableWindow
   {
      function get windowOwner():NativeWindow;
      function set windowOwner( value:NativeWindow ):void;
 
      function respondToOwnerWindowActivated( event:Event ):void;
      function respondToOwnerWindowMinimizedOrRestored( event:NativeWindowDisplayStateEvent ):void;
      function respondToOwnerWindowClosing( event:Event ):void;
   }
}

package labs.otuome.air.myapp.view.panel
{
   import flash.display.NativeWindow;
   import flash.display.NativeWindowDisplayState;
   import flash.events.Event;
   import flash.events.MouseEvent;
   import flash.events.NativeWindowDisplayStateEvent;
 
   import mx.events.FlexEvent;
 
   import spark.components.Button;
   import spark.components.RichText;
 
   /**
    * Spark Window component subclass.
    * @author Hasan Otuome
    */
   public class FloatingPanelView extends FloatingPanelUI implements OwnableWindow
   {
      ///////////////////////////////////////////////////////////////////////////
      // PRIVATE PROPERTIES
      ///////////////////////////////////////////////////////////////////////////
      private var _panelTitle:String;
      private var _windowOwner:NativeWindow;
      //////////////////////////////////////////////////////////////////////////
      // PUBLIC PROPERTIES
      /////////////////////////////////////////////////////////////////////////
      [SkinPart (required=false)]
      public var header:Button;
 
      [SkinPart (required=false)]
      public var toggle:Button;
 
      [SkinPart (required=false)]
      public var contentTitle:RichText;
 
      /**
      * Sets the panel's title. 
      * @param value
      */		
      public function set panelTitle( value:String ):void
      {
           _panelTitle = value;
      }
      /**
      * Allows you to specify an owner for this Spark 
      * Window instance. Used only until the Flex SDK 
      * adds support for owned native windows to Spark 
      * Windows.
      */		
      public function get windowOwner():NativeWindow
      {
           return _windowOwner;
      }
      public function set windowOwner( value:NativeWindow ):void
      {
           _windowOwner = value;
      }
      ///////////////////////////////////////////////////////////////////////////
      // PUBLIC METHODS
      ///////////////////////////////////////////////////////////////////////////
      /**
      * Constructor 
      */		
      public function FloatingPanelView()
      {
        super();
 
        addEventListener( FlexEvent.CREATION_COMPLETE, _onCreationComplete, false, 0, true );
      }
      //---------- OwnableWindow implementations --------------------
      /**
      * Adjust the display ordering of this 
      *	instance as it relates to its owner. 
      */
      public function respondToOwnerWindowActivated( event:Event ):void
      {
        this.nativeWindow.orderInFrontOf( _windowOwner );
      }
 
      /**
      * Show/hide this instance based 
      *	on the display state of its owner. 
      */
      public function respondToOwnerWindowMinimizedOrRestored( event:NativeWindowDisplayStateEvent ):void
      {
        switch (true)
        {
           case (event.beforeDisplayState == NativeWindowDisplayState.MINIMIZED):
             this.restore();
             break;
           case (event.afterDisplayState == NativeWindowDisplayState.MINIMIZED):
             this.minimize();
             break;
        }
      }
 
      /**
      * Close this instance when its owner is closed. This 
      *	will be handled automatically if the owner is 
      *	the main application window.  
      */
      public function respondToOwnerWindowClosing( event:Event ):void
      {
        this.close();
      }
      //////////////////////////////////////////////////////////////////////////
      // OVERRIDES
      /////////////////////////////////////////////////////////////////////////
 
      ////////////////////////////////////////////////////////////////////////
      // PRIVATE METHODS
      ///////////////////////////////////////////////////////////////////////
      /**
      * CREATION_COMPLETE event handler. 
      * Ensures this instance responds to 
      * display state changes of the 
      * instance's owner. 
      * @param e
      */		
      private function _onCreationComplete( e:FlexEvent ):void
      {
        if (_windowOwner)
        {
           _windowOwner.addEventListener( Event.ACTIVATE, respondToOwnerWindowActivated, false, 0, true );
           _windowOwner.addEventListener( NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE, respondToOwnerWindowMinimizedOrRestored, false, 0, true );
           _windowOwner.addEventListener( Event.CLOSING, respondToOwnerWindowClosing, false, 0, true );
        }
 
        removeEventListener( FlexEvent.CREATION_COMPLETE, _onCreationComplete );
      }
   }
}

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 );
}