<![CDATA[
			import mx.controls.Button;
			import mx.core.IFlexDisplayObject;
			override protected function createNavItem(label:String, icon:Class=null):IFlexDisplayObject{
				var navItem:Button = super.createNavItem(label,icon) as Button;
				navItem.addEventListener(MouseEvent.ROLL_OVER, mouseOverHandler, false, 0, true);
				navItem.addEventListener(MouseEvent.ROLL_OUT, mouseOutHandler, false, 0, true);
				return navItem;
			}
			private function mouseOverHandler(e:MouseEvent):void{
				var b:Button = e.target as Button;
 
				b.setStyle("textDecoration","underline");
			}
			private function mouseOutHandler(e:MouseEvent):void{
				var b:Button = e.target as Button;
 
				b.setStyle("textDecoration","none");
			}
		]]>

var arr:Array;
const LEN:int = 500000;
var t:Number;
arr = createRandomArray(LEN);
 
t = getTimer();
firstMethod(arr);
trace("firstMethod:",getTimer() - t);
t= getTimer();
secondMethod(arr);
trace("secondMethod:",getTimer() - t);
//----------------------------------
 
function firstMethod(arr:Array):void {
for (var i:int = 0; i < arr.length; i++) {
arr[i] = Math.random();
}
 
}
function secondMethod(arr:Array):void {
var len:int = arr.length;
for (var i:int = 0; i <  len; i++) {
arr[i] = Math.random();
}
}
function createRandomArray(len:int):Array {
var arr:Array = new Array();
for (var i:int = 0; < len; i++) {
arr[i] = Math.random();
}
return arr;
}

public static function interpolateColor (fromColor:uint,
toColor:uint, progress:Number):ColorTransform {
 
var k:Number = 1 - progress;//вычисляем множитель
//разложение на состовляющие ARGB
var fromA:uint = (fromColor >>  24) & 0xFF;
var fromR:uint = (fromColor >> 16) & 0xFF;
var fromG:uint = (fromColor >> 8) & 0xFF;
var fromB:uint = fromColor & 0xFF;
 
var toA:uint = (toColor >> 24) & 0xFF;
var toR:uint = (toColor >> 16) & 0xFF;
var toG:uint = (toColor >> 8) & 0xFF;
var toB:uint = toColor & 0xFF;
//находим результат
var resultA:uint = fromA * k + toA * progress;
var resultR:uint = fromR * k + toR * progress;
var resultG:uint = fromG * k + toG * progress;
var resultB:uint = fromB * k + toB * progress;
//Сооединяем составляющие ARGB и возвращаем результат
var cT:ColorTransform = new ColorTransform();
cT.color = (resultA << 24 | resultR << 16 | resultG << 8 | resultB);
return cT;
}

package ru.pulseneon.util {
 
import flash.geom.ColorTransform;
 
/**
* Определяет методы для работы с цветом.
* @langversion 3.0
* @author Aleksey Matveev
* @version 0.1
*/
public class ColorUtil {
//--------------------------------------------------------------------------
//
//  Public prop
//
//--------------------------------------------------------------------------
/**
* 24 бита
*/
public static const BIT_24:uint = 24;
/**
* 15-бит
*/
public static const BIT_16:uint = 16;
/**
* 8-бит
*/
public static const BIT_8:uint = 8;
/**
* Коэффициент нормировки DEC=255,HEX=0xff
*/
public static const HEX_255:uint = 0xFF;
//--------------------------------------------------------------------------
//
//  Constructor
//
//--------------------------------------------------------------------------
 
public function ColorUtil() {
//empty
}
//--------------------------------------------------------------------------
//
//  Public methods
//
//--------------------------------------------------------------------------
/**
* Интерполяция цвета. Нахождение цвета на промежутке двух цветов
* @param	fromColor — начальное значение цвета
* @param	toColor — конечное значение цвета
* @param	progress — Процент перехода в виде десятичного числа(от 0 до 1), где 0 обозначает начало, а 1 — конец.
* @return Возвращает объект ColorTransform. Своства color, которого хранит цвет на интервале fromColor-toColor. При progress = 0 : fromColor; При rogress = 1 : toColor;
*/
public static function interpolateColor (fromColor:uint, toColor:uint, progress:Number):ColorTransform {
var k:Number = 1 - progress;
//разложение на состовляющие
var fromA:uint = (fromColor >> BIT_24) & HEX_255;
var fromR:uint = (fromColor >> BIT_16) & HEX_255;
var fromG:uint = (fromColor >> BIT_8) & HEX_255;
var fromB:uint = fromColor & HEX_255;
 
var toA:uint = (toColor >> BIT_24) & HEX_255;
var toR:uint = (toColor >> BIT_16) & HEX_255;
var toG:uint = (toColor >> BIT_8) & HEX_255;
var toB:uint = toColor & HEX_255;
//находим результат
var resultA:uint = fromA * k + toA * progress;
var resultR:uint = fromR * k + toR * progress;
var resultG:uint = fromG * k + toG * progress;
var resultB:uint = fromB * k + toB * progress;
//Сооединяем составляющие ARGB и возвращаем результат
var cT:ColorTransform = new ColorTransform();
cT.color = (resultA << BIT_24 | resultR << BIT_16 | resultG << BIT_8 | resultB);
return cT;
}
/**
* Интерполяция цвета. Нахождение цвета на промежутке двух цветов
* @param	fromColor - начальный цвет
* @param	toColor - конечный цвет
* @param	progress — Процент перехода в виде десятичного числа(от 0 до 1), где 0 обозначает начало, а 1 — конец.
* @return Возвращает объект ColorTransform.
*/
public static function interpolateTransform(fromColor:ColorTransform, toColor:ColorTransform, progress:Number):ColorTransform {
var k:Number = 1-progress;
var resultColor:ColorTransform = new ColorTransform
(
fromColor.redMultiplier * k   + toColor.redMultiplier * progress
, fromColor.greenMultiplier * k + toColor.greenMultiplier * progress
, fromColor.blueMultiplier * k  + toColor.blueMultiplier * progress
, fromColor.alphaMultiplier * k + toColor.alphaMultiplier * progress
, fromColor.redOffset * k       + toColor.redOffset * progress
, fromColor.greenOffset * k     + toColor.greenOffset * progress
, fromColor.blueOffset * k      + toColor.blueOffset * progress
, fromColor.alphaOffset*k    + toColor.alphaOffset*progress
)
return resultColor;
}
}
 
}

package ru.pulseneon.effects.image {
import flash.geom.Rectangle;
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.DisplayObject;
/**
* Пиксельный эффект Мозаика.
* При "0" - это оригинал, "1" - тоже оригинал.
* @author Aleksey Matveev
* @version 0.1
*/
public class MosaicImage extends Bitmap {
 
//--------------------------------------------------------------------------
//
//  Private prop
//
//--------------------------------------------------------------------------
private var _src:BitmapData;
private var _pixelSize:uint;
//--------------------------------------------------------------------------
//
//  Constructor
//
//--------------------------------------------------------------------------
/**
* Конструктор.
* @param	viewObj - ресурс для которого применяеться эффект
* @param	pixelSize - размер писксела.
*
*/
public function MosaicImage(viewObj:DisplayObject, pixelSize:uint = 0 ) {
super();
_src = new BitmapData(viewObj.width, viewObj.height);
_src.draw(viewObj);
_pixelSize = pixelSize;
render();
}
//--------------------------------------------------------------------------
//
//  Getters and Setters
//
//--------------------------------------------------------------------------
/**
* Размер пикселя.Обновление/рендеринг происходит после установки значения.
*/
public function get pixelSize():uint { return _pixelSize; }
public function set pixelSize(value:uint):void {
_pixelSize = value;
render();
}
//--------------------------------------------------------------------------
//
//  Public methods
//
//--------------------------------------------------------------------------
/**
* Управление рендрингом.
*/
public function render():void {
//trace("Render");
if (_pixelSize == 0 || _pixelSize == 1) {
bitmapData = _src;
return;
}
var colorX:uint;
var colorY:uint;
var _w:uint = _src.width;
var _h:uint = _src.height;
 
//steps
var numRow:uint = Math.round(_w / _pixelSize);
var numColum:uint = Math.round(_h / _pixelSize);
 
//trace(numHorSteps, numVertSteps);
 
var bmd:BitmapData = new BitmapData(_w, _h, false);
 
for (var i:int = 0; i <= numRow; i++) {
for (var j:int = 0; j <= numColum; j++) {
if (i == numRow) {
colorX = _pixelSize * (numRow - 1);
}else {
colorX = _pixelSize * i;
}
if (j == numColum) {
colorY = _pixelSize * (numColum - 1);
}else {
colorY = _pixelSize * j;
}
//draw
bmd.fillRect(new Rectangle(i * _pixelSize, j * _pixelSize, _pixelSize, _pixelSize),
_src.getPixel(colorX, colorY));
}
}
//display
bitmapData = bmd;
}
/**
* Чистка мусора.
* Вызывается для уничтожения
*/
public function destroy():void {
_src.dispose();
_src = null;
bitmapData = null;
}
}
}