public class MyMacroCommand extends SequenceCommand
{
	public function MyMacroCommand()
	{
		// Commands for Macrobot to prepare before execution.
		addCommand(CommandA, new MyEvent());
		addCommand(CommandB, new MyEvent());
		addCommand(CommandC, new MyEvent());
 
		// Custom-prepared commands.
		var command:Command = new CommandD();
		command.event = new MyEvent();
		addCommandInstance(command);
 
		command = new CommandE();
		command.event = new MyEvent();
		addCommandInstance(command);
 
		command = new CommandF();
		command.event = new MyEvent();
		addCommandInstance(command);
	}
}

public class MyCommandWhichHappensToBeASubcommand extends AsyncCommand
{
	protected var timer:Timer;
 
	override public function execute():void
	{
		timer = new Timer(50, 1);
		timer.addEventListener(TimerEvent.TIMER_COMPLETE, timerCompleteHandler);
		timer.start();
	}
 
	protected function timerCompleteHandler(event:TimerEvent):void
	{
		timer.removeEventListener(TimerEvent.TIMER_COMPLETE, timerCompleteHandler);
		timer = null;
		dispatchComplete(true);
	}
}

public class MyMacroCommand extends SequenceCommand
{
	public function MyMacroCommand()
	{
			addCommand(new CommandA());
 
			var parallel1:ParallelCommand = new ParallelCommand();
			parallel1.addCommandInstance(new CommandB());
			parallel1.addCommandInstance(new CommandC());
			addCommandInstance(parallel1);
 
			addCommandInstance(new CommandD());
 
			var parallel2:ParallelCommand = new ParallelCommand();
			parallel2.addCommandInstance(new CommandE());
 
			var sequence:SequenceCommand = new SequenceCommand();
			sequence.atomic = false;
			sequence.addCommandInstance(new CommandF());
			sequence.addCommandInstance(new CommandG());
 
			parallel2.addCommandInstance(sequence);
			parallel2.addCommandInstance(new CommandH());
			parallel2.addCommandInstance(new CommandI());
			addCommandInstance(parallel2);
 
			addCommandInstance(new CommandJ());
	}
}

var matchingWidget:Widget;
for each (var widget:Widget in widgets)
{
	if (widget.id == idToMatch)
	{
		matchingWidget = widget;
		break;
	}
}
// Do what I need to do with the widget

package
{
	import mx.collections.ArrayCollection;
 
	public class AppModel
	{
		public var widgets:ArrayCollection;
 
		public function getWidgetById(id:uint):Widget
		{
			for each (var widget:Widget in widgets)
			{
				if (widget.id == id)
				{
					return widget;
				}
			}
		}
	}
}

package
{
	import flash.utils.Dictionary;
 
	import mx.collections.ArrayCollection;
	import mx.events.CollectionEvent;
 
	public class AppModel
	{
		private var _widgets:ArrayCollection;
 
		public function get widgets():ArrayCollection
		{
			return _widgets;
		}
 
		public function set widgets(value:ArrayCollection):void
		{
			if (_widgets != value)
			{
				var widget:Widget;
 
				if (_widgets)
				{
					_widgets.removeEventListener(CollectionEvent.COLLECTION_CHANGE, 
							widgets_collectionChangeHandler);
 
					for each (widget in _widgets)
					{
						removeWidgetFromIndex(widget);
					}
				}
 
				_widgets = value;
 
				if (_widgets)
				{
					_widgets.addEventListener(CollectionEvent.COLLECTION_CHANGE, 
							widgets_collectionChangeHandler, false, 0, true);
 
					for each (widget in _widgets)
					{
						addWidgetFromIndex(widget);
					}
				}
			}
		}
 
		protected var widgetById:Dictionary = new Dictionary();
 
		protected function removeWidgetFromIndex(widget:Widget):void
		{
			delete widgetById[widget.id];
		}
 
		protected function addWidgetToIndex(widget:Widget):void
		{
			widgetById[widget.id] = widget;
		}
 
		public function getWidgetById(id:uint):Widget
		{
			return widgetById[id];
		}
 
		protected function widgets_collectionChangeHandler(event:CollectionEvent):void
		{
			// All the various logic to update the dictionary when the
			// collection changes using the info contained in the event.
		}
	}
}

package com.aaronhardy
{
	import flash.utils.Dictionary;
 
	/**
	 * A list with accessors to its contained objects by id.
	 */
	public class IdIndexedList extends IndexableList
	{
		public function IdIndexedList(source:Array=null)
		{
			super(source);
		}
 
		protected var objectById:Dictionary = new Dictionary();
 
		/**
		 * Retrieves an object by id.
		 */
		public function getById(id:uint):Object
		{
			return objectById[id];
		}
 
		/**
		 * Retrieves an object's index by id.
		 */
		public function getIndexById(id:uint):int
		{
			return getItemIndex(getById(id));
		}
 
		/**
		 * @inheritDoc
		 */
		override protected function addToIndex(item:Object):void
		{
			super.addToIndex(item);
			if (item.hasOwnProperty('id'))
			{
				objectById[item['id']] = item;
			}
		}
 
		/**
		 * @inheritDoc
		 */
		override protected function removeFromIndex(item:Object):void
		{
			super.removeFromIndex(item);
			if (item.hasOwnProperty('id'))
			{
				delete objectById[item['id']];
			}
		}
	}
}

package com.aaronhardy
{
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IEventDispatcher;
	import flash.utils.Proxy;
	import flash.utils.flash_proxy;
 
	import mx.collections.ArrayList;
	import mx.collections.IList;
	import mx.events.CollectionEvent;
 
	[Event(name="collectionChange", type="mx.events.CollectionEvent")]
 
	/**
	 * A list with easily overridable functions for adding and removing items from indexes.
	 * This is generally extended to provide effecient accessors to objects by using indexes.
	 * @see http://aaronhardy.com
	 */
	public class IndexableList extends Proxy implements IEventDispatcher, IList
	{
		public function IndexableList(source:Array = null)
		{
			dispatcher = new EventDispatcher(this);
			this.source = source;
		}
 
		private var _list:IList
 
		public function get list():IList
		{
			return _list;
		}
 
		public function set list(value:IList):void
		{
			if (_list != value)
			{
				var item:Object;
 
				if (_list)
				{
					_list.removeEventListener(CollectionEvent.COLLECTION_CHANGE, 
						list_collectionChangeHandler);
 
				}
 
				for each (item in this)
				{
					removeFromIndex(item);
				}
 
				_list = value;
 
				if (_list)
				{
					_list.addEventListener(CollectionEvent.COLLECTION_CHANGE, 
						list_collectionChangeHandler, false, 0, true);
 
				}
 
				for each (item in this)
				{
					addToIndex(item);
				}
			}
		}
 
		/**
		 * @inheritDoc
		 */
		public function get source():Array
		{
			if (list && (list is ArrayList))
			{
				return ArrayList(list).source;
			}
			return null;
		}
 
		/**
		 *  @private
		 */
		public function set source(s:Array):void
		{
			list = new ArrayList(s);
		}
 
		/**
		 * @inheritDoc
		 */
		public function get length():int
		{
			return list ? list.length : 0;
		}
 
		/**
		 * @inheritDoc
		 */
		public function addItem(item:Object):void
		{
			addItemAt(item, length);
		}
 
		/**
		 * @inheritDoc
		 */
		public function addItemAt(item:Object, index:int):void
		{
			list.addItemAt(item, index);
			addToIndex(item);
		}
 
		/**
		 * @inheritDoc
		 */
		public function getItemAt(index:int, prefetch:int = 0):Object
		{
			return list.getItemAt(index, prefetch);
		}
 
		/**
		 * @inheritDoc
		 */
		public function getItemIndex(item:Object):int
		{
			return list.getItemIndex(item);
		}
 
		/**
		 * @inheritDoc
		 */
		public function itemUpdated(item:Object, property:Object = null, 
			oldValue:Object = null, newValue:Object = null):void
		{
			list.itemUpdated(item, property, oldValue, newValue);
		}
 
		/**
		 * @inheritDoc
		 */
		public function removeAll():void
		{
			for (var i:uint; i < list.length; i++)
			{
				removeFromIndex(list.getItemAt(i));
			}
 
			list.removeAll();
		}
 
		/**
		 * @inheritDoc
		 */
		public function removeItemAt(index:int):Object
		{
			var item:Object = list.removeItemAt(index);
			removeFromIndex(item);
			return item;
		}
 
		/**
		 * Removes an item from the list.  Throws an error if the item doesn't exist.
		 */
		public function removeItem(item:Object):void
		{
			removeItemAt(getItemIndex(item));
		}
 
		/**
		 * @inheritDoc
		 */
		public function setItemAt(item:Object, index:int):Object
		{
			var previous:Object = list.setItemAt(item, index);
			removeFromIndex(previous);
			addToIndex(item);
			return previous;
		}
 
		/**
		 * @inheritDoc
		 */
		public function toArray():Array
		{
			return list.toArray();
		}
 
		/**
		 * @private
		 */
		protected function list_collectionChangeHandler(event:CollectionEvent):void
		{
			dispatchEvent(event);
		}
 
		////////////////////////////////////////////////
 
		// Overrides of proxy to provide for...each support.
 
		override flash_proxy function deleteProperty(name:*):Boolean {
			return false;
		}
 
		override flash_proxy function getProperty(name:*):* {
			return null;
		}
 
		override flash_proxy function hasProperty(name:*):Boolean {
			return true;
		}
 
		override flash_proxy function nextNameIndex(index:int):int {
			return index < length ? index + 1 : 0;
		}
 
		override flash_proxy function nextName(index:int):String {
			return (index - 1).toString();
		}
 
		override flash_proxy function nextValue(index:int):* {
			return getItemAt(index - 1);
		}
 
		////////////////////////////////////////////////
 
		private var dispatcher:EventDispatcher;
 
		public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, 
			priority:int = 0, useWeakReference:Boolean = false):void{
			dispatcher.addEventListener(type, listener, useCapture, priority);
		}
 
		public function dispatchEvent(evt:Event):Boolean{
			return dispatcher.dispatchEvent(evt);
		}
 
		public function hasEventListener(type:String):Boolean{
			return dispatcher.hasEventListener(type);
		}
 
		public function removeEventListener(type:String, listener:Function, 
			useCapture:Boolean = false):void{
			dispatcher.removeEventListener(type, listener, useCapture);
		}
 
		public function willTrigger(type:String):Boolean {
			return dispatcher.willTrigger(type);
		}
 
		////////////////////////////////////////////////
 
		/**
		 * Adds an item to any indexes.
		 */
		protected function addToIndex(item:Object):void
		{
			// For easy overriding.
		}
 
		/**
		 * Removes an item from any indexes.
		 */
		protected function removeFromIndex(item:Object):void
		{
			// For easy overriding.
		}
	}
}

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009" 
					   xmlns:s="library://ns.adobe.com/flex/spark" 
					   xmlns:mx="library://ns.adobe.com/flex/mx"
					   initialize="createBaseCollection();">
	<fx:Script>
		<![CDATA[
			import mx.collections.ArrayCollection;
			import mx.collections.ListCollectionView;
 
			[Bindable]
			protected var baseCollection:ArrayCollection;
 
			[Bindable]
			protected var filteredCollection:ListCollectionView;
 
			protected function createBaseCollection():void
			{
				baseCollection = new ArrayCollection();
 
				for (var i:uint; i < 100; i++)
				{
					var widget:Widget = new Widget();
					widget.name = "Widget " + (i + 1);
					widget.price = Math.random() * 100;
					baseCollection.addItem(widget);
				}
			}
 
			protected function createAndFilterSeparateCollection():void
			{
				filteredCollection = new ListCollectionView();
				filteredCollection.list = baseCollection.list;
 
				filteredCollection.filterFunction = filterWidgets;
				filteredCollection.refresh();
			}
 
			protected function filterWidgets(item:Widget):Boolean
			{
				return item.price > 50;
			}
 
			protected function addWidget():void
			{
				var newWidget:Widget = new Widget();
				newWidget.name = 'NewWidget';
				newWidget.price = 90;
				baseCollection.addItemAt(newWidget, 0);
			}
		]]>
	</fx:Script>
 
	<s:layout>
		<s:VerticalLayout/>
	</s:layout>
 
	<s:Button label="Create Filtered Collection" click="createAndFilterSeparateCollection()"/>
	<s:Button label="Add Widget" click="addWidget();"/>
 
	<s:HGroup>
		<s:List dataProvider="{baseCollection}" labelField="name"/>
		<s:List dataProvider="{filteredCollection}" labelField="name"/>
	</s:HGroup>
</s:WindowedApplication>

package com.aaronhardy
{
	import flash.utils.Proxy;
	import flash.utils.flash_proxy;
 
	use namespace flash_proxy;
 
	/**
	 * Allows for maintaining an index and iterating through a vector or array of objects.
	 */
	public class VectorCursor extends Proxy
	{
		/**
		 * The collection the cursor is navigating.
		 */
		protected var collection:*;
 
		/**
		 * The current cursor index.
		 */
		protected var index:int;
 
		public function VectorCursor(collection:*)
		{
			this.collection = collection;
		}
 
		/**
		 * The item at the current cursor index.
		 */
		public function get current():Object
		{
			return index > -1 && index < collection.length ? collection[index] : null;
		}
 
		/**
		 * The current cursor index.
		 */
		public function get currentIndex():int
		{
			return index;
		}
 
		/**
		 * Moves the cursor index to the first item.
		 */
		public function seekFirst():void
		{
			index = 0;
		}
 
		/**
		 * Moves the cursor index to before the first item.
		 */
		public function seekBeforeFirst():void
		{
			index = -1;
		}
 
		/**
		 * Returns whether the cursor index is before the first item.
		 */
		public function get beforeFirst():Boolean
		{
			return index < 0;
		}
 
		/**
		 * Moves the cursor index to the last item.
		 */
		public function seekLast():void
		{
			index = collection.length - 1;
		}
 
		/**
		 * Moves the cursor index to after the last item.
		 */
		public function seekAfterLast():void
		{
			index = collection.length;
		}
 
		/**
		 * Returns whether the cursor index is after the last item.
		 */
		public function get afterLast():Boolean
		{
			return index >= collection.length;
		}
 
		/**
		 * Returns whether an item exists before the current cursor index.
		 */
		public function get hasPrevious():Boolean
		{
			return index > 0;
		}
 
		/**
		 * Moves the cursor index to and returns the previous item.
		 */
		public function movePrevious():Object
		{
			index--;
			return index > -1 ? collection[index] : null;
		}
 
		/**
		 * Returns whether an item exists after the current cursor index.
		 */
		public function get hasNext():Boolean
		{
			return index < collection.length - 1;
		}
 
		/**
		 * Moves the cursor index to and returns the next item.
		 */
		public function moveNext():Object
		{
			index++;
			return index < collection.length ? collection[index] : null;
		}
 
		// Overrides of proxy to provide for...each support.
 
		override flash_proxy function deleteProperty(name:*):Boolean {
			return false;
		}
 
		override flash_proxy function getProperty(name:*):* {
			return null;
		}
 
		override flash_proxy function hasProperty(name:*):Boolean {
			return true;
		}
 
		override flash_proxy function nextNameIndex(index:int):int {
			if (index > collection.length - 1)
				return 0;
			return index + 1;
		}
 
		override flash_proxy function nextName(index:int):String {
			return String(index - 1);
		}
 
		override flash_proxy function nextValue(index:int):* {
			return collection[index - 1];
		}
	}
}

var vector:Vector.<User> = new Vector.<User>();
vector.push(new User('Bob'));
vector.push(new User('Jan'));
vector.push(new User('Sam'));
 
var cursor:VectorCursor = new VectorCursor(vector);
 
// Iterate from first to last.
while (!cursor.afterLast)
{
	trace(cursor.current);
	cursor.moveNext();
}
 
trace('----------');
 
// Iterate from last to first.
cursor.seekLast();
while (!cursor.beforeFirst)
{
	trace(cursor.current);
	cursor.movePrevious();
}
 
trace('----------');
 
// For...each example from first to last.
for each (var item:Object in cursor)
{
	trace(item);
}

public class FilterAndMask extends Sprite
{
	public function FilterAndMask()
	{
		var mask:Shape = new Shape();
		mask.graphics.beginFill(0xff0000);
		mask.graphics.drawRect(25, 25, 50, 50);
		mask.graphics.endFill();
 
		var maskee:Sprite = new Sprite();
		maskee.graphics.beginFill(0x000000);
		maskee.graphics.drawRect(0, 0, 100, 100);
		maskee.graphics.endFill();
		maskee.filters = [new DropShadowFilter()];
 
		maskee.addChild(mask);
		maskee.mask = mask;
		addChild(maskee);
 
		maskee.addEventListener(MouseEvent.CLICK, clickHandler);
	}
 
	protected function clickHandler(event:MouseEvent):void
	{
		trace('click');
	}
}

// Copyright (c) 2010 Aaron Hardy
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
 
package com.aaronhardy
{
	import flash.display.DisplayObject;
	import flash.display.Graphics;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.utils.getQualifiedClassName;
 
	/**
	 * When a display object has cacheAsBitmap set to true and a mask applied to it, a bug appears 
	 * in the Flash Player which prevents the display object from dispatching any mouse events.  The
	 * workaround is to have an outer display object which has cacheAsBitmap set to true and a 
	 * nested display object which has the mask. When we run into this scenario of having both
	 * cacheAsBitmap set to true and a mask, this sprite will create a nested sprite that will 
	 * contain the mask and all children.
	 */
	public class CabMaskableSprite extends Sprite
	{
		/**
		 * The nested sprite that will contain the children and the mask when nesting is needed.
		 */
		protected var nestedDisplay:Sprite;
 
		private var _nest:Boolean;
 
		/**
		 * Whether to nest a sprite to support a filter and a mask.
		 */
		protected function get nest():Boolean
		{
			return _nest;
		}
 
		/**
		 * @private
		 */
		protected function set nest(value:Boolean):void
		{
			if (_nest != value)
			{
				value ? doNest() : doUnnest();
				_nest = value;
			}
		}
 
		/**
		 * Moves children and any mask to a nested sprite.
		 */
		protected function doNest():void
		{
			if (nestedDisplay)
			{
				throw new Error('nestedDisplay should not exist.');
			}
 
			addEventSwallowers();
 
			nestedDisplay = new Sprite();
			nestedDisplay.mouseEnabled = false;
 
			var i:int = numChildren - 1;
 
			while (i > -1)
			{
				nestedDisplay.addChildAt(removeChildAt(i), 0);
				i--;
			}
 
			addChild(nestedDisplay);
 
			nestedDisplay.mask = mask;
			super.mask = null;
 
			removeEventSwallowers();
		}
 
		/**
		 * Moves children and mask from the nested sprite to the parent (this sprite).
		 */
		protected function doUnnest():void
		{
			if (!nestedDisplay)
			{
				throw new Error('nestedDisplay should exist.');
			}
 
			addEventSwallowers();
 
			super.mask = nestedDisplay.mask;
			nestedDisplay.mask = null;
 
			var i:int = nestedDisplay.numChildren - 1;
 
			while (i > -1)
			{
				addChildAt(nestedDisplay.getChildAt(i), 0);
				i--;
			}
 
			removeChild(nestedDisplay);
			nestedDisplay = null;
 
			removeEventSwallowers();
		}
 
		/**
		 * Adds listeners for events that will be dispatched while nesting or unnesting.  We don't
		 * want these events to be dispatched because the process should be as transparent as
		 * possible.
		 */
		protected function addEventSwallowers():void
		{
			addEventListener(Event.ADDED, swallowEvent);
			addEventListener(Event.REMOVED, swallowEvent);
			addEventListener(Event.REMOVED_FROM_STAGE, swallowEvent);
			addEventListener(Event.ADDED_TO_STAGE, swallowEvent);
		}
 
		/**
		 * @see #addEventSwallowers()
		 */
		protected function removeEventSwallowers():void
		{
			removeEventListener(Event.ADDED, swallowEvent);
			removeEventListener(Event.REMOVED, swallowEvent);
			removeEventListener(Event.REMOVED_FROM_STAGE, swallowEvent);
			removeEventListener(Event.ADDED_TO_STAGE, swallowEvent);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function set filters(value:Array):void
		{
			super.filters = value; // Filters always go on the outer.
			evaluateForNesting();
		}
 
		/**
		 * @inheritDoc
		 */
		override public function set cacheAsBitmap(value:Boolean):void
		{
			super.cacheAsBitmap = value;
			evaluateForNesting();
		}
 
		/**
		 * @inheritDoc
		 */
		override public function get mask():DisplayObject
		{
			return nest ? nestedDisplay.mask : super.mask;
		}
 
		/**
		 * @private
		 */		
		override public function set mask(value:DisplayObject):void
		{
			nest ? nestedDisplay.mask = value : super.mask = value;
			evaluateForNesting();
		}
 
		/**
		 * Determine whether nesting is needed.
		 */
		protected function evaluateForNesting():void
		{
			nest = graphicsRequested || (cacheAsBitmap && mask);
		}
 
		/**
		 * Whether graphics have been requested at least once. Because graphical drawings can't
		 * be moved to/from the nested sprite, we must always have a nested sprite and use its
		 * graphics once graphics is requested for the first time.
		 */
		protected var graphicsRequested:Boolean = false;
 
		/**
		 * @inheritDoc
		 */
		override public function get graphics():Graphics
		{
			graphicsRequested = true;
			nest = true;
			return nestedDisplay.graphics;
		}
 
		/**
		 * @inheritDoc
		 */
		override public function addChild(child:DisplayObject):DisplayObject
		{
			return nest ? nestedDisplay.addChild(child) : super.addChild(child);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function addChildAt(child:DisplayObject, index:int):DisplayObject
		{
			return nest ? nestedDisplay.addChildAt(child, index) : super.addChildAt(child, index);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function removeChild(child:DisplayObject):DisplayObject
		{
			return nest ? nestedDisplay.removeChild(child) : super.removeChild(child);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function removeChildAt(index:int):DisplayObject
		{
			return nest ? nestedDisplay.removeChildAt(index) : super.removeChildAt(index);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function getChildAt(index:int):DisplayObject
		{
			return nest ? nestedDisplay.getChildAt(index) : super.getChildAt(index);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function getChildIndex(child:DisplayObject):int
		{
			return nest ? nestedDisplay.getChildIndex(child) : super.getChildIndex(child);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function setChildIndex(child:DisplayObject, index:int):void
		{
			nest ? nestedDisplay.setChildIndex(child, index) : super.setChildIndex(child, index);
		}
 
		/**
		 * @inheritDoc
		 */
		override public function get numChildren():int
		{
			return nest ? nestedDisplay.numChildren : super.numChildren;
		}
 
		/**
		 * Stops propagation of the event.
		 */
		protected function swallowEvent(event:Event):void
		{
			event.stopImmediatePropagation();
		}
	}
}

public class FilterAndMask extends Sprite
{
	public function FilterAndMask()
	{
		var mask:Shape = new Shape();
		mask.graphics.beginFill(0xff0000);
		mask.graphics.drawRect(25, 25, 50, 50);
		mask.graphics.endFill();
 
		var maskee:Sprite = new CabMaskableSprite();
		maskee.graphics.beginFill(0x000000);
		maskee.graphics.drawRect(0, 0, 100, 100);
		maskee.graphics.endFill();
		maskee.filters = [new DropShadowFilter()];
 
		maskee.addChild(mask);
		maskee.mask = mask;
		addChild(maskee);
 
		maskee.addEventListener(MouseEvent.CLICK, clickHandler);
	}
 
	protected function clickHandler(event:MouseEvent):void
	{
		trace('click');
	}
}