<?xml version="1.0" encoding="utf-8"?>
<s:Panel xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx"
  width="400" height="300" title="Custom Cursor Panel 1"
  rollOver="onRollOverHandler(event);"
  rollOut="onRollOutHandler(event);">
 <fx:Declarations>
  <flash:TextField id="cursorTxt" xmlns:flash="flash.text.*" border="true" autoSize="left" />
 </fx:Declarations>
 <fx:Script>
  <![CDATA[
   import mx.core.IChildList;
 
   protected var cursorID:int;
 
   public function onRollOverHandler(e:MouseEvent):void{
    cursorID = cursorManager.setCursor(Sprite);
 
    var cursorChildren:IChildList = systemManager.cursorChildren;
    if (!cursorChildren) return;
    var cursorHolder:Sprite = cursorChildren.getChildByName("cursorHolder") as Sprite;
    if (!cursorHolder || !cursorHolder.numChildren) return;
    var cursor:Sprite = cursorHolder.getChildAt(0) as Sprite;
    if (!cursor) return;
    cursor.addChildAt(cursorTxt, 0);
 
    addEventListener(MouseEvent.MOUSE_MOVE, onMouseEventHandler);
    addEventListener(MouseEvent.MOUSE_DOWN, onMouseEventHandler);
    addEventListener(MouseEvent.MOUSE_UP, onMouseEventHandler);
   }
 
   public function onRollOutHandler(e:MouseEvent):void{
    cursorManager.removeCursor(cursorID);
    removeEventListener(MouseEvent.MOUSE_MOVE, onMouseEventHandler);
    removeEventListener(MouseEvent.MOUSE_DOWN, onMouseEventHandler);
    removeEventListener(MouseEvent.MOUSE_UP, onMouseEventHandler);
   }
 
   public function onMouseEventHandler(e:MouseEvent):void{
    cursorTxt.text = e.type + " ("+ e.localX + " : " + e.localY + ")";
   }
  ]]>
 </fx:Script>
</s:Panel>

package com.ticore.utils  {
 import flash.display.DisplayObject;
 import flash.display.Sprite;
 
 /**
  * 提供一個 proxy 類別，給 Flex CursorManager 設定 cursor
  * CursorProxy 另外宣告一靜態的 getter/setter 供存取 cursor 實體
  * 每次 CursorProxy 實體被創建時，都會將靜態 cursor 實體加入自己 display list 下
  * 
  * @author Ticore Shih
  */
 public class CursorProxy extends Sprite {
 
  static protected var _cursor_:DisplayObject;
 
  static public function get cursor():DisplayObject{
   return _cursor_;
  }
 
  static public function set cursor(value:DisplayObject):void{
   _cursor_ = value;
   if (!_cursorProxy_) return;
   while (_cursorProxy_.numChildren) {
    _cursorProxy_.removeChildAt(0);
   }
   _cursorProxy_.addChild(_cursor_);
  }
 
 
  static protected var _cursorProxy_:CursorProxy;
 
  public function CursorProxy() {
   _cursorProxy_ = this;
   if (_cursor_) _cursorProxy_.addChild(_cursor_);
  }
 }
}

<?xml version="1.0" encoding="utf-8"?>
<s:Panel xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx"
  width="400" height="300" title="Custom Cursor Panel 1"
  rollOver="onRollOverHandler(event);"
  rollOut="onRollOutHandler(event);">
 <fx:Declarations>
  <flash:TextField id="cursorTxt" xmlns:flash="flash.text.*" border="true" autoSize="left" />
 </fx:Declarations>
 <fx:Script>
  <![CDATA[
   import com.ticore.utils.CursorProxy;
   import mx.core.IChildList;
 
   protected var cursorID:int;
 
   public function onRollOverHandler(e:MouseEvent):void{
 
    cursorID = cursorManager.setCursor(CursorProxy);
    CursorProxy.cursor = cursorTxt;
    addEventListener(MouseEvent.MOUSE_MOVE, onMouseEventHandler);
    addEventListener(MouseEvent.MOUSE_DOWN, onMouseEventHandler);
    addEventListener(MouseEvent.MOUSE_UP, onMouseEventHandler);
   }
 
   public function onRollOutHandler(e:MouseEvent):void{
    cursorManager.removeCursor(cursorID);
    removeEventListener(MouseEvent.MOUSE_MOVE, onMouseEventHandler);
    removeEventListener(MouseEvent.MOUSE_DOWN, onMouseEventHandler);
    removeEventListener(MouseEvent.MOUSE_UP, onMouseEventHandler);
   }
 
   public function onMouseEventHandler(e:MouseEvent):void{
    cursorTxt.text = e.type + " ("+ e.localX + " : " + e.localY + ")";
   }
  ]]>
 </fx:Script>
</s:Panel>

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
     xmlns:s="library://ns.adobe.com/flex/spark" 
     xmlns:mx="library://ns.adobe.com/flex/mx">
 <fx:Script>
  <![CDATA[
   Mod;
  ]]>
 </fx:Script>
 <s:layout>
  <s:VerticalLayout verticalAlign="middle" horizontalAlign="center" />
 </s:layout>
 <s:ModuleLoader id="modLdr" url="Mod.swf" width="50%" height="50%"/>
</s:Application>

<?xml version="1.0" encoding="utf-8"?>
<s:Module xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx"
  width="100%" height="100%">
 <s:Panel width="100%" height="100%" title="Module" />
</s:Module>

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
     xmlns:s="library://ns.adobe.com/flex/spark" 
     xmlns:mx="library://ns.adobe.com/flex/mx">
 <fx:Script>
  <![CDATA[
   Mod;
  ]]>
 </fx:Script>
 <s:layout>
  <s:VerticalLayout verticalAlign="middle" horizontalAlign="center" />
 </s:layout>
 <s:ModuleLoader id="modLdr" url="Mod.swf" width="50%" height="50%"
   ready="event.target.child.styleManager.initProtoChainRoots();" />
</s:Application>

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx">
 <fx:Script>
  <![CDATA[
   import org.robotlegs.mvcs.*;
 
   // include RobotLegs framework.
   Actor;
   Command;
   Context;
   Mediator;
  ]]>
 </fx:Script>
 <s:ModuleLoader url="modules/RLModule.swf" />
</s:Application>

<?xml version="1.0" encoding="utf-8"?>
<s:Module xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx" xmlns:modules="modules.*">
 <fx:Declarations>
  <modules:RLModuleContext contextView="{this}" />
 </fx:Declarations>
</s:Module>

package modules {
 import flash.system.ApplicationDomain;
 
 import org.robotlegs.mvcs.Context;
 
 public class RLModuleContext extends Context {
 
  override public function startup():void{
   mediatorMap.mapView(RLModule, RLModuleMediator);
  }
 }
}

package modules {
 import org.robotlegs.mvcs.Mediator;
 
 public class RLModuleMediator extends Mediator {
 
  [Inject]
  public var view:RLModule;
 }
}

package {
	import mx.collections.ICollectionView;
	import mx.collections.IList;
	import mx.collections.ISort;
	import mx.collections.ISortField;
	import mx.collections.Sort;
	import mx.styles.AdvancedStyleClient;
 
	import spark.components.DataGrid;
	import spark.components.Grid;
	import spark.components.gridClasses.GridColumn;
	import spark.components.gridClasses.GridSortField;
	import spark.events.GridEvent;
	import spark.events.GridSortEvent;
 
	/**
	 *  Multi-column sortable data grid class.
	 *  Extends spark data grid and override columnHeaderGroup_clickHandler function.
	 *  Provide multi-column sort function when ctrl + left click on column header.
	 */
	public class MultiColSortableDataGrid extends DataGrid {
 
		/**
		 *  @private
		 */
		override protected function columnHeaderGroup_clickHandler(event:GridEvent):void {
			const column:GridColumn = event.column;
			var columnIndices:Vector.<int>;
 
			if (!enabled || !sortableColumns || !column || !column.sortable)
				return;
 
			columnIndices = Vector.<int>([column.columnIndex]);
 
			// If the sort isn't cancelled, will also update the columnHeaderGroup
			// visibleSortIndiciatorIndices.
 
			sortByMultiColumns(columnIndices, true, event.ctrlKey);
		}
 
 
 
	    /**
		 *  Copy and modify from DataGrid::sortByColumns function.
	     *  Add one more argument multiColSort, decide if continue to use old sort fields.
		 *  Achieve multi-column sort function.
	     */
		public function sortByMultiColumns(columnIndices:Vector.<int>,
							isInteractive:Boolean = false , multiColSort:Boolean = false):Boolean {
 
			const dataProvider:ICollectionView = this.dataProvider as ICollectionView;
			if (!dataProvider)
				return false;
 
			var sort:ISort = dataProvider.sort;
			if (sort) {
				sort.compareFunction = null;
			} else {
				sort = new Sort();
			}
			var sortFields:Array = createSortFields(columnIndices, sort.fields, isInteractive);
			if (!sortFields)
				return false;
 
			var oldSortFields:Array = (dataProvider.sort) ? dataProvider.sort.fields : null;
 
 
			// implements multi-column sort function.
			if (multiColSort && oldSortFields) {
				if (columnHeaderGroup) {
					var colSortIndices:Vector.<int> = columnHeaderGroup.visibleSortIndicatorIndices;
					for (var j:int = colSortIndices.length - 1 ; j >= 0 ; --j) {
						var idx:int = colSortIndices[j];
						if (columnIndices.indexOf(idx) < 0) {
							columnIndices.unshift(idx);
						}
					}
				}
 
				outer: for (var i:int = oldSortFields.length - 1 ; i >= 0 ; --i) {
					var oldField:ISortField = oldSortFields[i] as ISortField;
 
					for (var k:int = 0 ; k < sortFields.length ; ++k) {
						var newField:ISortField = sortFields[k] as ISortField;
 
						if (newField.name == oldField.name) {
							continue outer;
						}
					}
					sortFields.unshift(oldField);
				}
			}
 
 
			// Dispatch the "changing" event. If preventDefault() is called
			// on this event, the sort operation will be cancelled.  If columnIndices or
			// sortFields are changed, the new values will be used.
			if (isInteractive) {
				// This is a shallow copy which means only the pointers to the ISortField objects
				// are copied to the new Array, not the ISortField objects themselves.
				if (oldSortFields)
					oldSortFields = oldSortFields.concat();
 
				if (hasEventListener(GridSortEvent.SORT_CHANGING)) {
					const changingEvent:GridSortEvent =
						new GridSortEvent(GridSortEvent.SORT_CHANGING,
						false, true,
						columnIndices,
						oldSortFields, /* intended to be read-only but no way to enforce this */
						sortFields);
 
					// The event was cancelled so don't sort.
					if (!dispatchEvent(changingEvent))
						return false;
 
					// Update the sort columns since they might have changed.
					columnIndices = changingEvent.columnIndices;
					if (!columnIndices)
						return false;
 
					// Update the new sort fields since they might have changed.
					sortFields = changingEvent.newSortFields;
					if (!sortFields)
						return false;
				}
			}
 
			// Remove each old SortField that's not a member of the new sortFields Array
			// as a "styleClient" of this DataGrid.
 
			if (oldSortFields) {
				for each (var oldSortField:ISortField in oldSortFields) {
					var oldASC:AdvancedStyleClient = oldSortField as AdvancedStyleClient;
					if (!oldASC || (oldASC.styleParent != this) || (sortFields.indexOf(oldASC) != -1))
						continue;
					removeStyleClient(oldASC);
				}
			}
 
			// Add new SortFields as "styleClients" of this DataGrid so that they
			// inherit this DataGrid's locale style. 
 
			for each (var newSortField:ISortField in sortFields) {
				var newASC:AdvancedStyleClient = newSortField as AdvancedStyleClient;
				if (!newASC || (newASC.styleParent == this))
					continue;
				addStyleClient(newASC);
			}
 
			sort.fields = sortFields;
 
			dataProvider.sort = sort;
			dataProvider.refresh();
 
			if (isInteractive) {
				// Dispatch the "change" event.
				if (hasEventListener(GridSortEvent.SORT_CHANGE)) {
					const changeEvent:GridSortEvent =
						new GridSortEvent(GridSortEvent.SORT_CHANGE,
						false, true,
						columnIndices,
						oldSortFields, sortFields);
					dispatchEvent(changeEvent);
				}
 
				// Update the visible sort indicators.
				if (columnHeaderGroup)
					columnHeaderGroup.visibleSortIndicatorIndices = columnIndices;
			}
 
			return true;
		}
 
 
	    /**
	     *  @private
	     *  Copy from DataGrid::createSortFields function.
	     */
		private function createSortFields(columnIndices:Vector.<int>,
									previousFields:Array, preservePrevious:Boolean):Array {
			if (columnIndices.length == 0)
				return null;
 
			var fields:Array = new Array();
 
			for each (var columnIndex:int in columnIndices) {
				var col:GridColumn = this.getColumnAt(columnIndex);
				if (!col)
					return null;
 
				var dataField:String = col.dataField;
 
				// columns all must have a dataField or a labelFunction or a sortCompareFunction
				if (dataField == null && col.labelFunction == null && col.sortCompareFunction == null)
					return null;
 
				const isComplexDataField:Boolean = (dataField && (dataField.indexOf(".") != -1));
				var sortField:ISortField = null;
				var sortDescending:Boolean = col.sortDescending;
 
				// Check if we just sorted this column.
				sortField = findSortField(dataField, fields, isComplexDataField);
 
				// If we haven't sorted by this column yet, check if
				// we've sorted by this column in the previous sort.
				if (!sortField && previousFields)
					sortField = findSortField(dataField, previousFields, isComplexDataField);
				else
					preservePrevious = false;
 
				// Previously sorted column, so flip sortDescending.
				if (sortField)
					sortDescending = !sortField.descending;
 
				// Create a SortField from the column.  If the sortField was found in the
				// previousFields and we need to preserve them, create a new sort field for the column.
				if (!sortField || preservePrevious)
					sortField = col.sortField;
 
				col.sortDescending = sortDescending;
				sortField.descending = sortDescending;
				fields.push(sortField);
			}
 
			return fields;
		}
 
 
	    /**
	     *  @private
	     *  Copy from DataGrid::getColumnAt function.
	     */
		private function getColumnAt(columnIndex:int):GridColumn {
			const grid:Grid = grid;
			if (!grid || !grid.columns)
				return null;
			const columns:IList = grid.columns;
			return ((columnIndex >= 0) && (columnIndex < columns.length)) ?
											columns.getItemAt(columnIndex) as GridColumn : null;
		}
 
 
		/**
		 *  @private
		 *  Copy from DataGrid::findSortField function.
		 * 
		 *  Finds a SortField using the provided dataField and returns it.
		 *  If the dataField is complex, it tries to find a GridSortField
		 *  with a matching dataFieldPath.
		 *
		 *  @param dataField The dataField of the column.
		 *  @param fields The array of SortFields to search through.
		 *  @param isComplexDataField true if the dataField is a path.
		 */
		private static function findSortField(dataField:String, fields:Array, isComplexDataField:Boolean):ISortField {
			if (dataField == null)
				return null;
			for each (var field:ISortField in fields) {
				var name:String = field.name;
				if (isComplexDataField && (field is GridSortField)) {
					name = GridSortField(field).dataFieldPath;
				}
				if (name == dataField)
					return field;
			}
			return null;
		}
	}
}

package {
	import flash.display.Sprite;
 
	public class EmbedTest extends Sprite {
 
		config::EMBED_SRC {
			[Embed(source=config::EMBED_SRC)]
			public var Cls:Class;
		}
 
		public function EmbedTest() {
			config::EMBED_SRC {
				addChild(new Cls());
			}
		}
 
	}
}

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
     xmlns:s="library://ns.adobe.com/flex/spark" 
     xmlns:mx="library://ns.adobe.com/flex/mx" fontSize="14">
 <s:layout>
  <s:HorizontalLayout verticalAlign="middle" horizontalAlign="center" />
 </s:layout>
 
 <s:VGroup gap="12">
  <s:Label text="TextInput" />
  <s:TextInput id="txt1" contentBackgroundColor="#DDDDDD"
    maxChars="3" widthInChars="8" />
  <s:TextInput text="{txt1.text}"/>
  <s:Label text="txt1.text: {txt1.text}"/>
  <s:Button label="trace(txt1.text);" click="trace(txt1.text);"/>
 </s:VGroup>
 
 <s:VGroup gap="12">
  <s:Label text="TextArea" />
  <s:TextArea id="txt2" contentBackgroundColor="#DDDDDD"
    maxChars="3" heightInLines="1" widthInChars="8" />
  <s:TextInput text="{txt2.text}"/>
  <s:Label text="txt2.text: {txt2.text}"/>
  <s:Button label="trace(txt2.text);" click="trace(txt2.text);"/>
 </s:VGroup>
 
 <s:VGroup gap="12">
  <s:Label text="RichEditableText" />
  <s:RichEditableText id="txt3" backgroundColor="#DDDDDD"
    paddingLeft="4" paddingRight="4" paddingTop="4" paddingBottom="4"
    maxChars="3" heightInLines="1" widthInChars="8" />
  <s:TextInput text="{txt3.text}"/>
  <s:Label text="txt3.text: {txt3.text}"/>
  <s:Button label="trace(txt3.text);" click="trace(txt3.text);"/>
 </s:VGroup>
</s:Application>

package {
 import flash.events.ProgressEvent;
 import mx.preloaders.SparkDownloadProgressBar;
 
 public class MySparkDownloadProgressBar extends SparkDownloadProgressBar {
 
  override protected function showDisplayForDownloading(elapsedTime:int, event:ProgressEvent):Boolean {
   /*/
   trace("showDisplayForDownloading: elapsedTime = " + elapsedTime);
   trace("showDisplayForDownloading:" + event.bytesLoaded + " " +
    event.bytesTotal + " " + (event.bytesLoaded < event.bytesTotal / 2));
   //*/
 
   return elapsedTime > 100;
   // return elapsedTime > 700 && event.bytesLoaded < event.bytesTotal / 2;
  }
 }
}

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
  xmlns:s="library://ns.adobe.com/flex/spark"
  xmlns:mx="library://ns.adobe.com/flex/mx"
  preloader="MySparkDownloadProgressBar">
 
 <s:layout>
  <s:VerticalLayout verticalAlign="middle" horizontalAlign="center"/>
 </s:layout>
 
 <s:Button label="Button" />
 
</s:Application>

package {
 import mx.preloaders.DownloadProgressBar;
 
 public class MyDownloadProgressBar extends DownloadProgressBar {
 
  override protected function showDisplayForInit(elapsedTime:int, count:int):Boolean {
   return elapsedTime > 300 && count == 2;
  }
 
 }
}