Рано или поздно любой flex-разработчик понимает, что нужно что-то сделать с собственным “винегретом” в коде, состоящим из mxml-разметки вперемешку с inline-кодом. А, собственно, что с ним не так? Если кратко, то:

• код трудночитаем, из-за постоянного перехода внутри одного файла от as3 кода к mxml разметке и обратно;
• сильная связанность (нет возможности легко заменить разметку или реализацию);
• низкая переиспользуемость кода (трудно перенести код/разметку в другой проект);
• отсутствует возможность разделить обязанности между разработчиком и дизайнером (кто-нибудь помнит/пользовался Flash Catalyst?, ах да: Development and sales ended on April 23, 2012);
• сильно разросшийся размер файла;
• и так далее.

Почему же так происходит? Отчасти в этом виновата сама Adobe, которая не удосужилась привить нужные навыки будущим разработчикам. Официальный хелп пестрит примерами наподобие этого (это всего лишь примеры, но все же):

<?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"  
    height="450">  

    <s:layout>  
        <s:VerticalLayout/>  
    </s:layout>  

    <fx:Script> <![CDATA[  
        import spark.events.IndexChangeEvent;  
        private function myChangedHandler(event:IndexChangeEvent):void  
        {  
            var selIndices:Vector.<int> = event.currentTarget.selectedIndices;  
            var selItems:Vector.<Object> = event.currentTarget.selectedItems;  
            var numItems:Number = selIndices.length;  
            selIndicesTA.text = "";  
            selItemsTA.text = "";  
            for (var i:Number = 0; i<numItems; i++)  
            {  
                selIndicesTA.text = selIndicesTA.text + selIndices[i] + "\n";  
                selItemsTA.text = selItemsTA.text + selItems[i] + "\n";  
            }  
        }  
    ]]>  
    </fx:Script>  
 
    <s:List allowMultipleSelection="true" change="myChangedHandler(event);">  
        <mx:ArrayCollection>  
            <fx:String>Flex</fx:String>  
            <fx:String>Flash Builder</fx:String>  
            <fx:String>Flash</fx:String>  
            <fx:String>Director</fx:String>  
            <fx:String>Dreamweaver</fx:String>  
            <fx:String>ColdFusion</fx:String>  
        </mx:ArrayCollection>  
    </s:List>  

    <s:Label text="Selected indices"/>  
    <s:TextArea id="selIndicesTA" height="75"/>  
    <s:Label text="Selected items"/>  
    <s:TextArea id="selItemsTA" height="75"/>
  
</s:Application>

Вместо того, чтобы пропагандировать “здоровое кодирование”, а также потому, что не смогла, как обычно, сразу сделать нормально. А, в конце концов, совсем открестилась от flex-а. Возможно, мы перекладываем с больной головы на здоровую, и во всем виновата прокрастинация разработчика. Но и она в основе своей вытекает, хоть и отчасти, из предыдущей проблемы. (Действительно ленивый программист сразу пишет рабочий, красивый и сопровождаемый код).

Не будем о грустном. Так как же можно отделить просо от гречки? Если хорошо поискать, то Adobe предлагает следующие варианты:

• использовать <fx:Script> блок. Собственно, от его использования мы и пытаемся избавиться;
• инлайн обработчики событий:

<s:Button label="Convert" 
click="celsius.text=String(Math.round((Number(fahrenheit.text)-32)/1.8 * 10)/10);"/>

• в отдельном as файле: <fx:Script source=”includes/Sample3Script.as”/>.

Много кода в инлайн обработчике не напишешь. Нельзя использовать операторы сравнения. Да и не похож этот вариант на разделение, скорее наоборот. Проходим мимо.

Описывание кода в отдельном as файле ни к чему, кроме головной боли, не ведет. Как минимум, код в пустом (безо всяких package, class и тд) файле выглядит странно, запутывает и приводит в уныние, наверное, все современные IDE. Кто-нибудь сейчас так пишет? Получается, название статьи расходится с её содержанием. Зачем она нужна непонятно (см. абзац “Почему так происходит”).

Вот мы все ругаем Adobe за Flex. Так ведь да, в один прекрасный момент она сама это поняла и переписала часть фреймворка, как надо. Ввела новый жизненный цикл компонентов и отделила логику/поведение компонентов от их внешнего вида и увеличила цифру у фреймворка аж до 4.00. Можно даже почитать, как правильно готовить такие компоненты. Переписать все компоненты сил не хватило, теперь этим занимается Apache Foundation.

Что же делать? И как быть? Наверное, многие уже поняли, к чему я клоню, и вспомнили о старом, добром CodeBehind-е.  Идея этого архитектурного паттерна проста: всю бизнес-логику пишем на чистом as3 (базовый класс), а расположение и внешний вид контролов, описываем, используя mxml-разметку. Все контролы, которые будут использоваться в коде, должны иметь id и быть описаны в базовом классе как публичные переменные с соответствующим типом. Звучит страшно, но на самом деле все просто. Рассмотрим пример:

// BaseControlPanel.as 
public class BaseControlPanel extends Group 
    { 
        public var stopButton : Button; 
        public var startButton: Button; 
        public function BaseControlPanel() 
        { 
            super(); 
        } 
 
 
        /** 
         * @inheritDoc 
         */ 
        override protected function createChildren():void 
        { 
            super.createChildren(); 
            stopButton.addEventListener(MouseEvent.CLICK, onStopButtonClicked); 
        } 
 
 
        /** 
         * Обработчик клика по кнопке старт 
         * @param e 
         */ 
        protected function onStartButtonClicked(e:MouseEvent):void 
        { 
            trace("Start"); 
        } 
 
 
        /** 
         * Обработчик клика по кнопке стоп 
         * @param e 
         */ 
        private function onStopButtonClicked(e:MouseEvent):void 
        { 
            trace("Stop"); 
        } 
    } 
 
// ControlPanelView.mxml 
<?xml version="1.0"?> 
<local:BaseControlPanel xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:local="*" xmlns:layouts="spark.layouts.*" 
                        xmlns:components="spark.components.*"> 
 
    <local:layout> 
        <layouts:HorizontalLayout paddingLeft="5" paddingTop="5"/> 
    </local:layout> 
 
    <!-- Кнопка запуска --> 
    <components:Button id="startButton" label="start" click="onStartButtonClicked(event)"/> 
 
    <!-- Кнопка остановки --> 
    <components:Button id="stopButton" label="stop"/> 
 
</local:BaseControlPanel>

В приведенном примере мы видим два варианта подписки на событие клика по кнопке. Стоп-кнопку мы подписываем на клик mxml файле. Для этого необходимо, чтобы обработчик события был виден, т.е. был либо protected либо public. Старт-кнопку мы подписываем в createChildren, сразу после того, как она создастся. Оба варианта приемлемы. Вариант с подпиской в разметке, как нам кажется, короче, но не так универсален. Если нам нужно будет создать еще один вариант разметки, нам придется еще раз подписывать кнопку на это событие, что избыточно и легко может привести к ошибке, если мы забудем это сделать. С другой стороны, если нам нужно подписаться на это событие не сразу, или подписать вообще другой компонент (который также может послать это событие), то сделать это без изменения as3 кода не получится. А так как именно эту проблему мы и решаем, то вариант с подпиской на событие в разметке в данном случае подходит лучше. Используем тот вариант, который решает нашу задачу лучше.

Таким образом, мы частично решили поставленные в начале статьи задачи, и даже получили некоторые другие преимущества:

• создание конструктора класса;
• возможность тестировать логику приложения отдельно от её представления;
• возможность наследоваться от базовой логики, без необходимости нести с собой mxml-мусор.

Но, как и у любого другого шаблона, у CodeBehind есть не только плюсы, но и минусы:

• увеличилось количество набираемого кода;
• увеличилось количество файлов/классов для редактирования (что приводит к частому переключению между вкладками в IDE);
• использование наследования вместо композиции, что ведет к увеличению иерархии наследования;
• необходимость в предоставлении ссылок-заглушек при тестировании базовых классов;
• возможно частичное нарушение инкапсуляции и наследования.

Другим вариантом реализации отделения логики от разметки является приём, называемый CodeFront (или code in front). Идея его (вы наверное и сами догадались) так же проста и кристальна, как и в случае с CodeBehind, и заключается в том, что сначала мы реализуем расположение компонентов, и только потом наполняем их жизнью (добавляем логику). Пример:

// BaseControlPanelView.mxml 
<?xml version="1.0"?> 
<s:Group xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:local="*" xmlns:layouts="spark.layouts.*" 
         xmlns:components="spark.components.*" xmlns:s="library://ns.adobe.com/flex/spark"> 
    <!-- 
        /** 
         * Внешний вид панели управления 
         * Created 18.04.2014 
         * Version 1.0 
         * Copyright (c) 2014 
         * @author ChessMax (www.chessmax.ru) 
         */ 
    --> 
 
 
    <s:layout> 
        <layouts:HorizontalLayout paddingLeft="5" paddingTop="5"/> 
    </s:layout> 
 
 
    <!-- Кнопка запуска --> 
    <components:Button id="startButton" label="start"/> 
 
 
    <!-- Кнопка остановки --> 
    <components:Button id="stopButton" label="stop"/> 
 
 
</s:Group> 
// ControlPanel.as 
public class ControlPanel extends BaseControlPanelView 
    { 
        public function ControlPanel() 
        { 
            super(); 
        } 
 
 
        /** 
         * @inheritDoc 
         */ 
        override protected function createChildren():void 
        { 
            super.createChildren(); 
 
 
            startButton.addEventListener(MouseEvent.CLICK, onStartButtonClicked); 
            stopButton .addEventListener(MouseEvent.CLICK, onStopButtonClicked); 
        } 
 
 
        /** 
         * Обработчик клика по кнопке старт 
         * @param e 
         */ 
        protected function onStartButtonClicked(e:MouseEvent):void 
        { 
            trace("Start"); 
        } 
 
 
        /** 
         * Обработчик клика по кнопке стоп 
         * @param e 
         */ 
        private function onStopButtonClicked(e:MouseEvent):void 
        { 
            trace("Stop"); 
        } 
    }

Используя CodeFront, нам больше нет необходимости описывать все необходимые переменные в классе, чтобы использовать их в логике. Так как мы наследуемся от mxml-разметки, то компилятор делает это за нас. Но теперь мы лишены возможности назначить обработчик события inline-внутри mxml-разметки, так как описан он будет только в наследнике. Также нет возможности полностью заменить layout получившегося компонента, по понятным причинам. Да и перенести логику в другой проект без layout-а теперь не получится. Возможно, поэтому этот вариант гораздо менее популярен, чем CodeBehind.

Заключение.

CodeBehind/CodeFront - архитектурный прием, который позволяет относительно легко сделать код чистым и структуированным, что  легко дает возможность модифицировать его в будущем. Хотя поначалу довольно непросто привыкнуть писать код так, и это сильно раздражает. Даже кажется, что мы делаем слишком много дополнительной работы. Но, как говорится, стоит только начать, а уж когда втянетесь… Становится легче абстрагировать логику от разметки. Гораздо легче наследоваться от чистых AS3 классов, нежели от MXML классов с необходимостью изменять layout. Попробуйте один из перечисленных приемов в своем проекте. И обязательно оставляйте комментарии о своем положительном/отрицательном использовании перечисленных техник.

Почитать:

Code Behind
Code behind in Flex and WPF
Flex and WPF: A comparison – Part 2b
Code-Behind and Flex 2.0 (Partial Classes)
Building components by using code behind
Creating components and enforcing separation of concerns with Flex
Best Practice: Code Behind versus MXML Script Blocks versus View Helper

У многих новичков as3 возникает вопрос: в чем разница между свойствами

target

currentTarget

Свойство

currentTarget

addEventListener

target

Посмотрим отличия на примере. Пусть у нас есть подложка

cover:Sprite

cover.addEventListener(MouseEvent.CLICK, onClick);

и обрабатываем событие в слушателе

private function onClick(event:MouseEvent):void
{
    // обработка события
}

Когда пользователь кликает по любой из кнопок, добавленных на cover, вызовется функция

onClick()

event.currentTarget

event.target

button.mouseChildren = false;

Вот и всё. Если остались вопросы – прошу задавать в комментариях, это очень поможет улучшить и оптимизировать пост.

Не забудьте также ознакомиться с документацией по ActionScript3

• Документация Event.target
• Документация Event.currentTarget

Unity3D – один из самых популярных, кроссплатформенных движков для разработки игр. Что же в нем такого особенного и чем вызвана такая популярность этого движка.

• В первую очередь, конечно, его стоимость. Не обязательно покупать PRO-лицензию для того чтобы начать делать игру. Функционал Free-версии, конечно, несколько ограничен, но работать с ней можно. Из прямых конкурентов похвастать подобным может разве что Torque 3D.
• Во-вторых – кроссплатформенность. Unity3D позволяет создавать и портировать игры под Windows (в т.ч. и phone), Mac, Linux, iOS, Android, BlackBerry, Xbox 360, PS3, Wii, WEB-плеер. Такого набора поддерживаемых платформ нет, пожалуй, ни в одном из прочих движков.
• В-третьих поддерживаемые языки программирования. Это C#, JavaScript и Boo, не буду говорить за всех, но для меня это несомненный плюс при выборе, скажем, между Unity3D и Unreal Engine, где в качестве ЯП используется UnrealScript.
• И в-четвертых хорошая документация, активное сообщество и множество уроков, что тоже играет свою роль при выборе.

Из всего вышеперечисленного можно сделать вывод, что движок, как нельзя лучше подходит для небольших команд и инди-разработчиков. Впрочем, крупные компании тоже не обделяют Unity вниманием. Что подтверждает долгосрочный контракт  Unity Technologies с Electronic Arts  (есть уже и плоды – Need for Speed: World, а так же проект EA SPORTS).

О производительности и “красивости графики” говорить не буду. Это довольно спорный вопрос, здесь все больше зависит от прямоты рук, профессионализма моделлеров и дизайнеров. В сети много холиваров по поводу того, кто круче CryEngine, UDK или Unity3D, не будем начинать еще один. В любом случае уровень графики приличный.

Что, на мой взгляд, несколько нелогично в Unity – это работа с GUI, собственно это то, что я не могу визуально построить окно с кнопками, чекбоксами и прочим. Создавать их возможно только программно. С одной стороны это нормально и даже более привычно. Но кажется мне не совсем логичным, то, что строить трехмерные миры я могу тыкая мышкой, а чтобы собрать какую-нибудь пресловутую панельку с кнопочками надо написать пару десятков строк кода. Пока этот момент решается установкой дополнительных плагинов, будем надеяться, что в будущем прикрутят к редактору по умолчанию.

Так же непривычно отсутствие главного класса проекта, так сказать точки входа, и скрипты вешаются непосредственно на объекты. Учитывая, что работа идет с префабами назвать это минусом нельзя, но подход, однако, своеобразный.

Из минусов не могу не подметить, что с движком идет очень скудный набор префабов, текстур и скриптов. Я понимаю, что каждая игра уникальна со своими моделями и прочим, но хотя-бы травы, деревьев и текстур земли можно было добавить и побольше, чем по две. Да и, скажем, скрипт симулирующий физику движения транспорта не помешал бы. Зато у нас есть обширный магазин ассетов, доступный прямо из редактора (меню Window -> Asset Store), в котором можно как купить себе готовые вещи, так и выставить свое на продажу.

Ну, и что мне режет глаз, это лапша из разношерстного кода. Вот пример, открываю Unity, кидаю на сцену стандартный компонент First Person Controller. И что я вижу, на нем висит три скрипта:

• FPSInputController.js
• CharacterMotor.js
• MouseLook.cs

Что это за солянка, половина на JS, вторая на C#, хорошо хоть на Boo нет. Писали бы уж все на одном языке или дублировали, раз движок позиционируется как мультиязычный.

Кстати о JavaScript, он тут немного “не тот”, что мы привыкли видеть в браузере. В Unity3D js более “продвинутый” и похож больше на ActionScript. Хотя они все одного поля ягоды, так что проблем с этим возникнуть не должно. И не стоит полагать, что раз JavaScript, то будет все тормозить, как в IE. Скорость исполнения на достойном уровне, хотя и немного проигрывает скриптам на шарпе.

Подытожим вышесказанное. Unity3D качественный, мощный игровой движок. Свои недостатки, которых не так уж и много, правят быстро. Еще года два назад их было куда больше.

Пусть у нас есть массив чисел

var numbers:Array = [2, 7, 4, 9, 12, 6, 13, 19];

и стоит задача найти максимальное или минимальное число из тех, которые находятся в этом массиве. Первое что приходит на ум, это перебрать массив и найти элемент с максимальным (минимальным) значением. Но есть и другой путь.

Все знают функции 

Math.min()

Math.max()

apply()

Function

var min:Number = Math.min.apply(null, numbers);
var max:Number = Math.max.apply(null, numbers);

Это неплохой способ сократить код, такая запись намного короче перебора в цикле. Но остаётся ещё один вопрос — производительность.

Тест производительности

Сравним 

Math.min()

var min:Number = NaN;
var i:uint;
var num:Number;
var count:uint = numbers.length;
for (i = 0; i < count; ++i)
{
    num = numbers[i];
    if (isNaN(min) || min > num) min = num;
}

Массив чисел сгенерирован случайным образом и содержит 20 элементов, поиск элементов выполняется 1000000 раз. Итак, результаты:

Numbers: 128,-332,-280,-250,-89,328,91,-279,163,-141,-186,-187,98,-18,-102,-363,-161,-338,-7,342
[Math.min()] Result: -363 Time: 992 ms
[for(;;){ }] Result: -363 Time: 7266 ms

Как видно, минимум оба метода выдают одинаковый, но реализация перебором при этом работает медленнее. Отмечу, что с увеличением размера массива разница увеличивается. Это логично, ведь при использовании

Math.min()

Таким образом мы имеем более простой и более быстрый метод нахождения минимального или максимального значения в массиве чисел.

В конце полезные ссылки:

• Adobe ActionScript 3 – Math
• Adobe ActionScript 3 – Function
• http://stackoverflow.com/questions/424800/what-is-the-best-way-to-get-the-minimum-or-maximum-value-from-an-array-of-number

Доброго дня! Как оказалось, несмотря на то, что у flash-разработчиков уже довольно давно появилась возможность полноценно и без костылей использовать правую и среднюю кнопки мыши, многие попросту пропустили эту новость.

Начиная с версии Flash-плеера 11.2 появилось несколько новых событий мыши:

• RIGHT_CLICK – клик правой кнопкой мыши;
• RIGHT_MOUSE_DOWN – нажатие правой кнопки мыши;
• RIGHT_MOUSE_UP – отпускание правой кнопки мыши;
• MIDDLE_CLICK – клик средней кнопкой мыши;
• MIDDLE_MOUSE_DOWN – нажатие средней кнопки мыши;
• MIDDLE_MOUSE_UP – отпускание средней кнопки мыши.

И небольшой пример использования:

package
{
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;

    public class Main extends Sprite
    {
        private var _container:Sprite;

        public function Main():void
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }

        private function init(e:Event = null):void
        {
            _container = new Sprite();
            _container.graphics.beginFill(0xF2F2F2, 1);
            _container.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
            _container.graphics.endFill();
            _container.x = _container.y = 0;
            addChild(_container);

            _container.addEventListener(MouseEvent.CLICK, clickHandler);
            _container.addEventListener(MouseEvent.RIGHT_CLICK, rightClickHandler);
            _container.addEventListener(MouseEvent.MIDDLE_MOUSE_DOWN, middleDownHandler);
            _container.addEventListener(MouseEvent.MIDDLE_MOUSE_UP, middleUpHandler);
        }

        private function clickHandler(e:MouseEvent):void
        {
            var sprite:Sprite = new Sprite();
            sprite.graphics.beginFill(0x000000, Math.random());
            sprite.graphics.drawCircle(0, 0, 10 + Math.random() * 10);
            sprite.graphics.endFill();
            sprite.x = mouseX;
            sprite.y = mouseY;
            _container.addChild(sprite);
        }

        private function rightClickHandler(e:MouseEvent):void
        {
            if (e.target != _container) _container.removeChild(e.target as DisplayObject);
        }

        private function middleDownHandler(e:MouseEvent):void
        {
            if (e.target != _container) e.target.startDrag();
        }

        private function middleUpHandler(e:MouseEvent):void
        {
            if (e.target != _container) e.target.stopDrag();
        }
    }

}

(ЛКМ – добавление объекта, ПКМ – удаление объекта, СКМ – перетаскивание объекта)

Для правильной работы со Spark компонентами и создания собственных компонентов, необходимо иметь понятие о том, как и по каким правилам они работают. Сегодня мы  рассмотрим базовые принципы, без знания которых невозможно эффективно использовать этот мощный фреймворк.

Итак, жизненный цикл каждого компонента во Flex фреймворке проходит следующие этапы:

• создание (construction);
• конфигурация (configuration);
• подключение/присоединение (attachment);
• инициализация (initialization);
• инвалидация (invalidation);
• взаимодействие (interaction);
• удаление (detachment);
• сборка мусора (garbage collection).

При наследовании компонентов разработчик может (должен) переопределять следующие методы:

• createChildren();
• commitProperties();
• measure();
• updateDisplayList().

Когда мы добавляем компонент с помощью mxml разметки

<local:MyComponent fontSize="12" width="100"/>

происходит следующее.

Сначала запускается этап создания, и инстанциируется экземпляр класса MyComponent. Затем происходит конфигурация, в течение которой компоненту выставляются свойства и стили, объявленные при добавлении компонента (применяются они позже). Пока внутри компонента не доступны свойства systemManager, stage, root и т.д. Но при этом могут вызываться get/set методы (конфигурация), поэтому при реализации необходимо правильно определять такие методы. Нельзя сразу применять изменения внутри метода, необходимо использовать валидацию.

private var _data:Object;
private var _dataChanged:Boolean;

private function set data(value:Object):void
{
    if (this._data !== value)
    {
        this._data = value;
        this._dataChanged = true;

        this.invalidateProperties();
    }
}

Теперь движемся дальше (до применений изменений мы дойдем чуть позже). Наступает этап подключения, в котором компонент добавляется на сцену, после чего происходит инициализация. Инициализацию рассмотрим подробнее.

Фазы инициализации:

• устанавливается значение свойства parent;
• событие «preinitialize»;
• создание дочерних компонентов createChildren() (для скинируемых компонентов это порождает вызов attachSkin(), про скины мы поговорим в следующий раз);
• событие «initialize», вызов метода инициализации initialize().

При переопределении метода createChildren() в наследниках, необходимо создавать здесь постоянные дочерние компоненты (которые должны проходить этапы создания, конфигурации и подключения), но не применять динамических изменений (это будет происходить на этапе валидации). Вызывать super.createChildren() лучше в конце переопределения.

private var _okButton:Button;

override protected function createChildren():void
{
    if (this._okButton === null)
    {
        this._okButton = new Button();
        this._okButton.label = 'OK';
        this._okButton.addEventListener(MouseEvent.CLICK, this.okButton_clickHandler);
    }

    this.addChild(this._okButton);
    super.createChildren();
}

После того как компонент инициализирован, наступает этап инвалидации. Компоненты Flex фреймворка используют отложенную валидацию изменений. Аналогично как мы делали выше с полем data: изменения сохраняются и помечаются как измененные, а валидация происходи позже. Это позволяется сохранить высокую производительность, в том числе за счет того, что изменения применяются не по одному, а сразу все. Чтобы сообщить флексу о том, что требуется валидация, необходимо вызывать один из методов инвалидации:

• изменение свойств – invalidateProperties();
• изменение размеров – invalidateSize();
• изменение отображения – invalidateDisplayList().

Для применения изменения свойств будет вызван метод commitProperties(), именно его и надо переопределять в наследниках для применения изменения данных. Для определения необходимости обновления используются флаги (_dataChanged в примере с set data).

override function protected commitProperties():void
{
    super.commitProperties();

    if (this._dataChanged)
    {
        this._dataChanged = false;

        // Применение изменения поля this._data
    }
}

Отметим, что, так как валидация происходит после инициализации, то в методе commitProperties() уже доступны дочерние элементы, созданные в createChildren().

При валидации размеров будет вызван метод measure(), который устанавливает предпочтительные размеры (поля measuredWidth, measuredHeight, measuredMinWidth, measuredMinHeight). Замечу, что метод не будет вызван при установленных explicitWidth/explicitHeight (значения, присвоенные пользователем: <s:Label width="100"/>). Пример:

override protected function measure():void
{
    var i:uint;
    var count:uint;
    var w:Number;
    var h:Number;
    var child:UIComponent;

    w = 0;
    h = 0;
    count = this.numChildren;
    for (i = 0; i < count; ++i)
    {
        child = this.getChildAt(i) as UIComponent;
        if (child !== null)
        {
            w = Math.max(w, child.getExplicitOrMeasuredWidth());
            h += child.getExplicitOrMeasuredHeight();
        }
    }

    measuredWidth = w;
    measuredHeight = h;

    measuredMinWidth = w;
    measuredMinHeight = h;
}

Валидация размеров вызывает метод updateDisplayList(). При переоределении этого метода в наследниках здесь следует позиционировать и устанавливать размеры дочерних элементов. Также можно перерисовывать например фон. Актуальный размер компонента выставляется именно здесь. Вызов super.updateDisplayList() снова советую делать в конце переопределения.

По окончании инвалидации рассылается событие «creationComplete», после чего компонент находится в рабочем состоянии и доступен для взаимодействия с ним.

Когда компонент уже не нужен – он удаляется со сцены (методами удаления или выставлением флага visible=false). Если при этом больше не существует ссылки на объект или она слабая, то компонент будет удален из памяти сборщиком мусора. Обратите внимание, что ссылки на объект могут сохраняться при использовании обработчиков событий, биндига, сохранении в качестве ключей в словаре и т.д., поэтому не забывайте отписываться от событий, если больше не требуется его слушать.

Полезные ссылки

• Implementing the component http://livedocs.adobe.com/flex/3/html/help.html?content=ascomponents_advanced_3.html#210915
• About creating advanced components http://livedocs.adobe.com/flex/3/html/help.html?content=ascomponents_advanced_2.html
• About creating advanced Spark components http://help.adobe.com/en_US/flex/using/WS460ee381960520ad-2811830c121e9107ecb-7fff.html
• Презентация Павла Кожина «Жизненный цикл компонентов» http://www.slideshare.net/Constantiner/flex-component-lifecycle-overview
• Developing Flex 4 Components Book http://blog.flashgen.com/2010/12/07/developing-flex-components-book-2/

Что такое изометрия, простым, человеческим языком, – это псевдо трехмерная проекция, при которой все объекты повернуты к нам под углом в 45 градусов, так, что мы видим три стороны фигуры. При этом масштаб фигур не изменяется в зависимости от их удаленности. Доступных к общему пользованию изометрических движков на AS3 на самом деле не так уж и много, можно пересчитать на пальцах и двух рук хватит. Расскажу про один из них – as3Isolib.

Библиотека с открытым исходным кодом. Легко допиливается под свои нужды. Глюков особо замечено не было. Скоростью, правда, не хвастается, но и жутко не тормозит. В либе присутствует только базовый функционал по отображению и сортировке, все прочие навороты придется допиливать самому. Из недостатков могу подметить, что последнее обновление на Google Code было в 2010 году. Скачать саму либу можно здесь.

Итак как ее использовать. весь “изометрический мир” представляет собой одну (для простых проектов) или несколько изометрических сцен IsoScene, которые отображаются через вьюпорт IsoView. Создадим простейшую изометрическую сцену.

package 
{
	import as3isolib.display.IsoView;
	import as3isolib.display.scene.IsoGrid;
	import as3isolib.display.scene.IsoScene;
	import flash.display.Sprite;
	import flash.events.Event;

	public class Main extends Sprite 
	{
		public function Main():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}

		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			// Создаем вьюпорт
			var view:IsoView = new IsoView(); 
			// Задаем ему размеры равные нашей флешке
			view.setSize(stage.stageWidth, stage.stageHeight);  
			// Добавляем его на сцену 
			addChild(view); 
			// Создаем изометрическую сцену
			var scene:IsoScene = new IsoScene();  
			// Добавляем сцену во вьюпорт 
			view.addScene(scene); 
			// Для наглядности добавим на сцену сетку
			scene.addChild(new IsoGrid());  
			// Рендерим сцену 
			scene.render(); 
		} 
	} 
}

Собственно сетку IsoGrid можно было и не добавлять, но тогда бы мы увидели просто пустой экран, что было бы не очень наглядно.

В библиотеке присутствуют стандартные примитивы например IsoBox, которые больше подходят для тестирования и отладки, чем для практического использования, но для примера вполне подойдут. Кроме того имеется IsoSprite, это уже более полезный объект, сам он не имеет внешнего представления и является контейнером для DisplayObject-ов. Проще говоря помещаем DisplayObject или набор нескольких в IsoSprite и они становятся частью “изометрического мира”. Добавим на сцену примитив IsoBox, IsoHexBox и IsoSprite.

package 
{
	import as3isolib.display.IsoSprite;
	import as3isolib.display.IsoView;
	import as3isolib.display.primitive.IsoBox;
	import as3isolib.display.primitive.IsoHexBox;
	import as3isolib.display.scene.IsoScene;
	import as3isolib.graphics.SolidColorFill;
	import flash.display.Sprite;
	import flash.events.Event;

	public class Main extends Sprite 
	{
		public function Main():void 
		{
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}

		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);

			// Создаем вьюпорт
			var view:IsoView = new IsoView(); 
			// Задаем ему размеры равные нашей флешке
			view.setSize(stage.stageWidth, stage.stageHeight); 
			// Добавляем его на сцену
			addChild(view); 
			// Создаем изометрическую сцену
			var scene:IsoScene = new IsoScene(); 
			// Добавляем сцену во вьюпорт
			view.addScene(scene); 

			// Создаем примитив IsoBox
			var box:IsoBox = new IsoBox(); 
			// Устанавливаем ему размер (ширина, длина, высота)
			box.setSize(50, 50, 50); 
			// Добавляем его на сцену
			scene.addChild(box); 

			// Создаем примитив IsoHexBox
			var hexBox:IsoHexBox = new IsoHexBox(); 
			// Задаем ему размер
			hexBox.setSize(50, 50, 40); 
			// Перемещаем его (x, y, z)
			hexBox.moveTo( -50, 0, 0); 
			// Зальем его красным цветом, чтоб не сливался с коробкой
			hexBox.fill = new SolidColorFill(0xFF0000, 1); 
			// Добавляем на сцену
			scene.addChild(hexBox); 

			// Создаем контейнер IsoSprite
			var sprite:IsoSprite = new IsoSprite(); 
			// Добавлем в него спрайты (массив DisplayObject'ов)
			sprite.sprites = [new Tree()];	
			// Задаем размеры контейнера
			sprite.setSize(50, 50, 50); 
			// Перемещаем его
			sprite.moveTo(60, 25, 0); 
			// И добавляем на сцену
			scene.addChild(sprite); 

			// Рендерим сцену
			scene.render(); 
		}
	}
}

О чем здесь следует сказать. Устанавливать размеры объекта (setSize(width, length, height) нужно обязательно. Иначе он не будет принимать участия в сортировке. Это не размер DisplayObject‘a, а размер объекта в изометрическом мире.

Перемещать объекты по изометрической сцене не сложнее, чем по обычной, у всех изометрических объектов имеются методы moveTo(x, y, z) и moveBy(x, y, z). Первый перемещает объект в указанные координаты. Второй смещает объект на указанное количество пикселей относительно текущей позиции. Координаты конечно нужно указывать в изометрической проекции, а не в экранной. Самим ничего естественно пересчитывать не придется, для этого в библиотеке есть класс IsoMath с соответствующими статическими методами isoToScreen() и screenToIso(). Кроме того у объекта IsoView есть удобные методы для перевода координат isoToLocal(), localToIso().
Напишем код, который будет перемещать объект IsoBox в координаты клика.

package 
{
	import as3isolib.display.IsoSprite;
	import as3isolib.display.IsoView;
	import as3isolib.display.primitive.IsoBox;
	import as3isolib.display.primitive.IsoHexBox;
	import as3isolib.display.scene.IsoGrid;
	import as3isolib.display.scene.IsoScene;
	import as3isolib.geom.Pt;
	import as3isolib.graphics.SolidColorFill;
	import eDpLib.events.ProxyEvent;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;

	public class Main extends Sprite 
	{
		private const GRIDSIDE:int = 25; 
		private const GRIDSIZE:int = 10; 
		private var _view:IsoView;
		private var _scene:IsoScene;
		private var _box:IsoBox;
		private var _hexBox:IsoHexBox;

		public function Main():void 
		{
			// Создаем вьюпорт
			_view = new IsoView(); 
			 // Создаем изометрическую сцену
			_scene = new IsoScene();
			// Создаем примитив IsoBox
			_box = new IsoBox(); 
			 // Создаем примитив IsoHexBox
			_hexBox = new IsoHexBox();

			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}

		private function init(e:Event = null):void 
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);

			// Задаем вью размеры равные нашей флешке
			_view.setSize(stage.stageWidth, stage.stageHeight); 
			// Добавляем его на сцену
			addChild(_view); 
			// Добавляем сцену во вьюпорт
			_view.addScene(_scene); 

			// Устанавливаем примитиву IsoBox размер (ширина, длина, высота)
			_box.setSize(GRIDSIDE, GRIDSIDE, GRIDSIDE); 
			// Добавляем его на сцену
			_scene.addChild(_box); 

			// Задаем примитиву IsoHexBox размер
			_hexBox.setSize(GRIDSIDE, GRIDSIDE, GRIDSIDE); 
			// Перемещаем его (x, y, z)
			_hexBox.moveTo(GRIDSIDE*2, 0, 0); 
			// Зальем его красным цветом, чтоб не сливался с коробкой
			_hexBox.fill = new SolidColorFill(0xFF0000, 1); 
			// Добавляем на сцену
			_scene.addChild(_hexBox); 

			// Создаем сетку
			var grid:IsoGrid = new IsoGrid(); 
			// устанавливаем ей размер
			grid.setGridSize(GRIDSIZE, GRIDSIZE, 0); 
			// сдвигаем  на 100 пикселей для удобства
			grid.moveTo( -100, -100, 0 ); 
			// добавляем ее на сцену
			_scene.addChild(grid); 

			// Рендерим сцену
			_scene.render(); 

			// вешаем слушатель клика на сцену
			_scene.addEventListener(MouseEvent.CLICK, handlerClick); 
		}

		private function handlerClick(e:ProxyEvent):void //ловим клики
		{
			// Преобразуем координаты клика из экранных в изометрические
			var pt:Pt = _view.localToIso(new Pt(stage.mouseX, stage.mouseY)); 
			// Округляем точку x по клетке
			pt.x = Math.round(pt.x / GRIDSIDE) * GRIDSIDE; 
			// Округляем точку y
			pt.y = Math.round(pt.y / GRIDSIDE) * GRIDSIDE; 
			// Перемещаем примитив Box в новые координаты
			_box.moveTo(pt.x, pt.y, pt.z); 
			// рендерим сцену
			_scene.render(); 
		}
	}
}

Как можно увидеть я беру не точные координаты клика, а округленные до ближайшего кратного GRIDSIDE (25), т.е. до ширины / длины ячейки. Хитрости никакой здесь нет, это делается чтобы объекты не пересекались, просто некрасиво.

Ну вот впрочем и все, остальное дело техники, переписывать сюда документацию особого смысла не вижу. Вводный экскурс по использованию библиотеки я вам дал, те кто заинтересуется может продолжить изучение либы в доках и ее исходниках.
И примерчик самого простенького редактора изометрической карты:

Доброго времени суток! Поговорим о такой вещи как поиск пути, чаще всего, конечно используемой в играх. В одних играх боты просто ходят взад-вперед по заранее предопределенному пути. В других юниты двигаются в определенном направлении, пока не встретят препятствие. Бывает что препятствия вообще не учитываются. Ну и наконец игры в которых юниты находят кратчайший путь до нужного им места в обход препятствий. Вот об этом и будет беседа.

Итак, как это работает. Алгоритмов поиска пути и их модификаций на самом деле достаточно много. Один из хорошо зарекомендовавших себя – AStar (А*), младший и более шустрый брат алгоритма Дейкстры. Его особенность в том, что он работает эвристически (грубо говоря интуитивно). Он обходит узел за узлом, переходя в теоретически наиболее ближний к цели узел, попутно корректируя путь, если это не так.

На сколько тот или иной узел близок к целевому определяется суммой расстояний от начального узла до текущего и от текущего до конечного. Например так:

g – стоимость пути от начального узла до текущего. Как видно на изображениях выше g складывается из стоимости всех пройденных узлов.
h – эвристическая стоимость пути от текущего узла до конечного. Мы не знаем ее наверняка, а рассчитываем, какова эта стоимость была бы если бы мы двигались по прямой.
На самом деле разные реализации алгоритма могут немного отличаться друг от друга. Здесь я рассчитываю h по теореме Пифагора, в других реализациях вы можете увидеть пересчет количества узлов до конечой точки или умножение вектора x на вектор y. Здесь всем заведует отношение скорости выполнения к возможной погрешности. Я же сейчас не ставлю перед собой задачи сделать наиболее быструю реализацию алгоритма, поэтому могу себе позволить более точные вычисления.

А теперь в коде:
Класс сетки/карты:

package  
{
	public class Grid 
	{
		private var _nodes:Vector.<Vector.<Node>>;
		private var _width:int;
		private var _height:int;

		public function Grid(width:int = 25, height:int = 25, walkableMap:Array = null) 
		{
			_width = width;
			_height = height;
			_nodes = new Vector.<Vector.<Node>>();
			for (var x:int = 0; x < _width; x++)
			{
				_nodes[x] = new Vector.<Node>();
				for (var y:int = 0; y < _height; y++)
				{
					_nodes[x][y] =  new Node(x, y, true);
					if (walkableMap && !walkableMap[x][y]) Node(_nodes[x][y]).walkable = false;
				}
			}
		}

		public function getNode(x:int = 0, y:int = 0):Node
		{
			return (x < 0 || x >= _width)?null:(y < 0 || y >= _height)?null:_nodes[x][y];
		}

		public function get nodes():Vector.<Vector.<Node>> 
		{
			return _nodes;
		}

	}

}

Класс узла:

package  
{
	public class Node
	{
		private var _g:Number;
		private var _h:Number;
		private var _f:Number;
		private var _x:int;
		private var _y:int;
		private var _walkable:Boolean;
		private var _parentNode:Node;

		public function Node(x:int, y:int, walkable:Boolean) 
		{
			_x = x;
			_y = y;
			_walkable = walkable;
		}

		public function get g():Number 
		{
			return _g;
		}

		public function set g(value:Number):void 
		{
			_g = value;
		}

		public function get h():Number 
		{
			return _h;
		}

		public function set h(value:Number):void 
		{
			_h = value;
		}

		public function get f():Number 
		{
			return _f;
		}

		public function set f(value:Number):void 
		{
			_f = value;
		}

		public function get parentNode():Node 
		{
			return _parentNode;
		}

		public function set parentNode(value:Node):void 
		{
			_parentNode = value;
		}

		public function get walkable():Boolean 
		{
			return _walkable;
		}

		public function set walkable(value:Boolean):void 
		{
			_walkable = value;
		}

		public function get x():int 
		{
			return _x;
		}

		public function get y():int 
		{
			return _y;
		}
	}
}

И непосредственно класс поиска пути:

package  
{
	/**
	 * Поиск пути
	 */
	public class PathFinder 
	{
		private static const ALIGNED:int = 1;
		private static const DIAGONAL:Number = 1.4;
		private static var _closed:Vector.<Node>;
		private static var _opened:Vector.<Node>;
		private static var _path:Vector.<Node>;

		public static function getPath(start:Node, end:Node, grid:Grid):Vector.<Node>
		{
			_closed = new Vector.<Node>();
			_opened = new Vector.<Node>();
			_path = new Vector.<Node>();
			start.g = 0;
			start.h = getDistance(start, end);
			start.f = start.g + start.h;
			start.parentNode = null;
			_opened.push(start);
			var currentNode:Node;

			while (_opened.length)
			{
				currentNode = _opened[0];
				_closed.push(_opened.shift());
				for (var x:int = currentNode.x-1; x <= currentNode.x+1; x++) 
				{
					for (var y:int = currentNode.y-1; y <= currentNode.y+1; y++) 
					{
						var testedNode:Node = grid.getNode(x, y);
						if (!testedNode || !testedNode.walkable || _closed.indexOf(testedNode) != -1) continue;
						if (_opened.indexOf(testedNode) == -1)
						{
							testedNode.g = currentNode.g + getLocalDistance(currentNode, testedNode);
							testedNode.h = getDistance(currentNode, testedNode);
							testedNode.f = testedNode.g + testedNode.h;
							testedNode.parentNode = currentNode;
							_opened.push(testedNode);
						}
						else
						{
							var tempG:Number = currentNode.g + getLocalDistance(currentNode, testedNode);
							if (tempG < testedNode.g) 
							{
								testedNode.g = tempG;
								testedNode.f = testedNode.g + testedNode.h;
								testedNode.parentNode = currentNode;
							}
						}
					}
				}
				_opened.sort(sortOpen);
				if (_opened.length && _opened[0] == end) return pathReconstruct(_opened[0]);
			}
			return null;
		}

		private static function pathReconstruct(lastNode:Node):Vector.<Node>
		{
			while (lastNode.parentNode)
			{
				_path.push(lastNode);
				lastNode = lastNode.parentNode;
			}
			_path.reverse();
			return _path;
		}

		private static function sortOpen(one:Node, two:Node):Number
		{
			return one.f - two.f;
		}

		private static function getDistance(one:Node, two:Node):Number
		{
			var catX:int = Math.abs(two.x - one.x);
			var catY:int = Math.abs(two.y - one.y);
			return Math.sqrt(catX * catX + catY * catY);
		}

		private static function getLocalDistance(one:Node, two:Node):Number
		{
			return (one.x == two.x || one.y == two.y)?ALIGNED:DIAGONAL;
		}
	}

}

Использовать довольно просто:

var grid:Grid = new Grid(25, 25); //Создает сетку 25 x 25 третьим параметром можно передать вектор проходимостей
var path:Vector.<Node> = PathFinder.getPath(grid.nodes[0][0], grid.nodes[24][24], grid);
trace(path);

Я привел вполне работоспособную, но в тоже время достаточно простую реализацию этого алгоритма. В реальных проектах вы вероятно захотите ввести еще стоимость клеток, ведь поверхность земли бывает неоднородной (лед, болота, зыбучие пески). Так же вы можете попробовать его ускорить, например, возможно положительно скажется на скорости работы замена пересортировки вектора открытого списка на сохранение индекса следующего узла. Или замена формулы вычисления стоимости h на более легкую. Вобщем желаю вам удачи в экспериментах!
И конечно же пример:
(клик – поиск пути и перемещение, Ctrl+клик – изменение проходимости узла)

При использовании регулярных выражений может встать задача написания шаблона, определяющего число из промежутка от X до Y, а не просто числа определенной длины. Удобного механизма для этого не предусмотрено и приходится составлять громоздкие шаблоны для каждого случая. Например для промежутка от 125 до 2819 шаблон буден выглядеть следующим образом (online генератор):

(12[5-9]|1[3-9][0-9]|[2-9][0-9]{2}|1[0-9]{3}|2[0-7][0-9]{2}|28[01][0-9])

Очевидно, что если границы не известны заранее, а меняются во время выполнения, то для создания таких шаблонов нужна функция, которая будет составлять такие шаблоны по указанным границам промежутка. Ниже приводится миграция Python генератора https://github.com/dimka665/range-regex на Java.

package ru.flaps.framework.util;

import java.util.*;

/**
 * Вспомогательный генератор шаблонов регулярных выражений и их частей
 * <span class="hide">Created 31.10.13</span>
 * @author greymag
 * @link https://github.com/dimka665/range-regex
 * Copyright 2013 FlaPS, Inc.<br/>
 */
public class RegExpGenerator
{
    /**
     * Функция для генерации регулярного выражения, под которое подпадает
     * любое число в промежутке между минимальным и максимальным включительно
     * @param min минимальное значение
     * @param max максимальное значение
     * @return шаблон
     */
    public static String intRange(final Integer min, final Integer max)
    {
        /*
        > intRange(12, 345)
        '1[2-9]|[2-9]\d|[1-2]\d{2}|3[0-3]\d|34[0-5]'
        */

        final List<String> subpatterns = new ArrayList<String>();

        Integer start = min;
        for (final Integer stop : split2Ranges(min, max))
        {
            subpatterns.add(range2Pattern(start, stop));
            start = stop + 1;
        }

        String listString = "";
        for (int i = 0; i < subpatterns.size(); ++i)
        {
            if (i > 0) listString += "|";
            listString += subpatterns.get(i);
        }
        return listString;
    }

    private static List<Integer> split2Ranges(final Integer min, final Integer max)
    {
        final Set<Integer> stops = new HashSet<Integer>();
        stops.add(max);

        Integer ninesCount = 1;
        Integer stop = fillByNines(min, ninesCount);

        while (min <= stop && stop < max)
        {
            stops.add(stop);

            ninesCount += 1;
            stop = fillByNines(min, ninesCount);
        }

        Integer zerosCount = 1;
        stop = fillByZeros(max, zerosCount) - 1;

        while (min < stop && stop < max)
        {
            stops.add(stop);

            zerosCount += 1;
            stop = fillByZeros(max, zerosCount) - 1;
        }

        final List<Integer> list = new ArrayList<Integer>(stops);
        Collections.sort(list);

        return list;
    }

    private static Integer fillByNines(final Integer integer, final Integer ninesCount)
    {
        final String integerStr = integer.toString();
        final String prefix = ninesCount > integerStr.length()
                ? "" : integerStr.substring(0, integerStr.length() - ninesCount);
        return Integer.parseInt(prefix + stringOfSize('9', ninesCount));
    }

    private static Integer fillByZeros(final Integer integer, final Integer zerosCount)
    {
        return integer - integer % (int)Math.pow(10, zerosCount);
    }

    private static String range2Pattern(final Integer start, final Integer stop)
    {
        String pattern = "";
        Integer anyDigitCount = 0;

        final String startStr = start.toString();
        final String stopStr = stop.toString();

        for (int i = 0; i < startStr.length(); ++i)
        {
            final String startDigit = startStr.substring(i, i + 1);
            final String stopDigit = stopStr.substring(i, i + 1);

            if (startDigit.equals(stopDigit))
            {
                pattern += startDigit;
            }
            else if (!startDigit.equals("0") || !stopDigit.equals("9"))
            {
                pattern += String.format("[%s-%s]", startDigit, stopDigit);
            }
            else
            {
                anyDigitCount++;
            }
        }

        if (anyDigitCount > 0) pattern += "\\d";
        if (anyDigitCount > 1) pattern += String.format("{%d}", anyDigitCount);

        return pattern;
    }

    private static String stringOfSize(char ch, int size)
    {
        final char[] array = new char[size];
        Arrays.fill(array, ch);
        return new String(array);
    }
}

Пример использования:

final String numPattern = RegExpGenerator.regex_for_range(10, 133);
// numPattern = 1\d|[2-9]\d|1[0-2]\d|13[0-3]
Boolean match;

match = "Hello, my value is 134!".matches("Hello, my value is (" + numPattern + ")!");
// match = false

match = "Hello, my value is 119!".matches("Hello, my value is (" + numPattern + ")!");
// match = true

Сама по себе тема создания своего курсора мыши довольно избита. Но сводится, как правило, к сокрытию “настоящего” курсора ОС и перемещению клипа в координаты мыши.
Мы побеседуем о другом. Как заменить “реальный” курсор ОС.
Начиная с версии Flash 10.2 у класса Mouse появились новые методы registerCursor для регистрации нового курсора и unregisterCursor, как не сложно догадаться, для обратной операции.
А так же свойство supportsNativeCursor, позволяющее проверить поддерживает ли ОС на которой выполняется ролик встроенные курсоры.
Внешний вид собственного курсора определяется классом MouseCursorData имеющий три полезных свойства:
data : Vector.<BitmapData> – вектор битмапдат – “кадров” курсора,
frameRate : Number – частота кадров анимации, да, да она может отличаться от frameRate самого ролика,
hotSpot : Point – активная точка курсора (по умолчанию 0, 0).

Преимущества перед “эмулированным курсором” на лицо:

• Не нужно следить “а не перекрыл ли его новый добавленный DisplayObject”
• При изменении масштаба ролика курсор остается не изменным
• Нет артефактов при выводе мыши за пределы ролика
• После клика пользователем правой кнопкой мыши не будет эффекта “двойного курсора”
• ???
• PROFIT

Ну и немного дегтя в бочку с медом, куда ж без него:

• Максимальный размер курсора 32×32 пикселя.

Как вы уже верно заметили, для отображения и анимации курсора нужен вектор битмапдат. Для удобства мы не будем эмбеддить набор картинок, а проведем растеризацию анимированного клипа.
Чтож приступим.
Для начала надо курсор нарисовать, художник из меня мягко скажем не особый, получился вот такой курсор:

Ну а теперь все вышесказанное в коде с комментариями:

package 
{
	import flash.display.BitmapData;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.ui.Mouse;
	import flash.ui.MouseCursorData;

	public class Main extends Sprite 
	{
		private const MY_CURSOR:String = "MySuperCursor"; //Определяем строковую константу - имя курсора

		public function Main():void 
		{
			if (Mouse.supportsNativeCursor) //Проверяем что ОС поддерживает встроенные курсоры
			{
				var cursorData:MouseCursorData = new MouseCursorData(); //Создаем новый экземпляр класса "параметров курсора"
				cursorData.data = getBitmapsVector(new MyCursorClip()); //Определяем вектор битмап. (Подразумеваю, что MyCursorClip это и есть нарисованный ранее курсор)
				cursorData.frameRate = stage.frameRate; //Определяем частоту кадров.
				Mouse.registerCursor(MY_CURSOR, cursorData); //Регистрируем курсор
				Mouse.cursor = MY_CURSOR; //Делаем курсор активным
			}
			else //Иначе, если в ОС нет поддержки курсоров, используем старый способ с сокрытием курсора
			{
				Mouse.hide();
				var mc:MovieClip = new MyCursorClip();
				mc.mouseEnabled = false;
				mc.x = mouseX;
				mc.y = mouseY;
				mc.addEventListener(Event.ENTER_FRAME, cursorFrameHandler);
				addChild(mc);
			}
		}

		/**
		 * Возвращает вектор битмапдат - кадров переданного клипа
		 * @param	mc преобразуемый в вектор клип
		 * @return Vector.<BitmapData> вектор битмапдат
		 */
		private function getBitmapsVector(mc:MovieClip):Vector.<BitmapData>
		{
			var vector:Vector.<BitmapData> = new Vector.<BitmapData>();
			for (var i:int = 0; i < mc.totalFrames; i++)
			{
				mc.gotoAndStop(i + 1);
				vector[i] = new BitmapData(32, 32, true, 0x000000);
				vector[i].draw(mc);
			}
			return vector;
		}

		/**
		 * Обработчик входа имитирующего курсор клипа в кадр. перемещает его в координаты "реального" курсора
		 * @param	e событие
		 */
		private function cursorFrameHandler(e:Event):void 
		{
			e.currentTarget.x = mouseX;
			e.currentTarget.y = mouseY;
		}
	}

}

И пример: