RichMedia+

package {
	import flash.display.Sprite;
	import flash.text.TextField;
	import flash.text.TextFormat;
 
	[SWF(width="300", height="200")]
	public class Main extends Sprite {
 
		public function Main() {
			var txt:TextField = new TextField();
			// txt.defaultTextFormat = new TextFormat("Microsoft JhengHei", 16);
			txt.defaultTextFormat = new TextFormat("微軟正黑體", 16);
			txt.text = "微軟正黑體";
			txt.x = 100;
			txt.y = 50;
			addChild(txt);
		}
	}
}

<languageVersion : 1.0;>
kernel PartialColor
<
    namespace : "PartialColor";
    vendor : "Ticore Shih";
    version : 1;
    description : "only keep saturation of assigned color";
>
{
 
    parameter float hue
    <
        defaultValue: 0.0;
        minValue: 0.0;
        maxValue: 360.0;
    >;
 
    parameter float range
    <
        defaultValue : 40.0;
        minValue : 0.0;
        maxValue : 180.0;
    >;
    input image4 src;
    output pixel4 dst;
 
    void evaluatePixel() {
        pixel4 inputColor = sampleNearest(src, outCoord());
        float minColor, maxColor, delta;
        float h, s, v;
        float r, g, b;
        float f, p, q, t;
        int i;
 
        r = inputColor.r; g = inputColor.g; b = inputColor.b;
 
        minColor = min(min(r , g) , b);
        maxColor = max(max(r , g) , b);
        delta = maxColor - minColor;
 
        // value
        v = maxColor;
        // saturation
        if (maxColor !=0.0 ) {
            s = delta / maxColor;
        }
 
        // hue
        if (maxColor == r) {
            h = (g - b) / delta;
        } else if (maxColor == g) {
            h = 2.0 + (b - r) / delta;
        } else {
            h = 4.0 + (r - g) / delta;
        }
        h *= 60.0;
        h = mod(h + 360.0, 360.0);
 
 
        float diff = min(mod(abs(hue - h - 360.0), 360.0), mod(abs(hue - h + 360.0), 360.0));
 
        // sine
 
        s *= sin(clamp(1.0 - diff / range, 0.0, 1.0) * 90.0 * 3.14159 / 180.0);
 
        s = clamp(s, 0.0, 1.0);
 
        if (s == 0.0) {
            r = g = b = v;
        } else {
            h /= 60.0;
            int i = int(floor(h));
            f = h - float(i);
 
            p = v * ( 1.0 - s );
            q = v * ( 1.0 - s * f );
            t = v * ( 1.0 - s * ( 1.0 - f ) );
 
            if (i == 0) {
                r = v; g = t; b = p;
            } else if (i == 1) {
                r = q; g = v; b = p;
            } else if (i == 2) {
                r = p; g = v; b = t;
            } else if (i == 3) {
                r = p; g = q; b = v;
            } else if (i == 4) {
                r = t; g = p; b = v;
            } else if (i == 5) {
                r = v; g = p; b = q;
            }
        }
 
        dst = pixel4(r, g, b, inputColor.a);
    }
}

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