• the first one is a Bitmap
• the second on is a MovieClipLoaderAsset

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
        layout="vertical"
        verticalAlign="middle"
        backgroundColor="white">
 
    <mx:Script>
        <![CDATA[
        	import mx.core.MovieClipLoaderAsset;
        	import mx.core.BitmapAsset;
            import mx.collections.ArrayCollection;
            
            [Embed(source="placeholder.swf")]
			private const ARTWORK_PLACE_HOLDER_SWF:Class;
			
			[Embed(source="placeholder.png")]
			private const ARTWORK_PLACE_HOLDER_PNG:Class;
 
            [Bindable]
            private var collection:ArrayCollection = new ArrayCollection();
 			
 			private function handleImage(e:Event):void{
 				
 				if(e.currentTarget.selectedValue == "PNG"){
 					
 					img.source = ARTWORK_PLACE_HOLDER_PNG;
 					
 				}else{
 					
 					img.source = ARTWORK_PLACE_HOLDER_SWF;
 					
 				}
 				
 			}
 			
            private function dumpImage(source:Image):void {
            	
            	var asset:* = source.content;
            	var data:BitmapData;
            	var bitmap:Bitmap;
            	
            	try{
            		
            		data = Bitmap(source.content).bitmapData;
                	bitmap = new Bitmap(data);
                	
                	collection.addItem({image:bitmap, label:"item #" + (collection.length + 1)});
            		
            	}catch(error:Error){
            		
            		var loader:Loader = new Loader();
            		
            		loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onBitmapData); 
            		           		
            		var swf:MovieClipLoaderAsset = asset as MovieClipLoaderAsset;            		
            		loader.loadBytes(swf.movieClipData);
            		
            	}
            	
            }
            
            private function onBitmapData(e:Event):void{
            			
            	e.target.removeEventListener(e.type, arguments.callee);
            			
            	var content: MovieClip = MovieClip((e.currentTarget as LoaderInfo).content)
            	var data:BitmapData = new BitmapData(content.width, content.height);
            	data.draw(content, null, null, null, null, true)
            	var bitmap:Bitmap = new Bitmap(data)
            			
            	collection.addItem({image:bitmap, label:"item #" + (collection.length + 1)});
            			
            }
            
        ]]>
    </mx:Script>
 
    <mx:HBox>
        <mx:Panel title="Source image">
            <mx:HBox verticalAlign="middle" horizontalAlign="center" width="100%" height="100%">
                <mx:Image id="img" source="{ARTWORK_PLACE_HOLDER_SWF}" />
            </mx:HBox>
            
            <mx:RadioButtonGroup id="imageSelector" change="handleImage(event)" />
            <mx:RadioButton label="SWF" selected="true" group="{imageSelector}" />
            <mx:RadioButton label="PNG" group="{imageSelector}" />
 
            <mx:ControlBar>
                <mx:Button label="Copy image" click="dumpImage(img)" />
            </mx:ControlBar>
        </mx:Panel>
 
        <mx:TileList id="tileList" dataProvider="{collection}" width="450" height="500" columnCount="4" verticalScrollPolicy="on">
            <mx:itemRenderer>
                <mx:Component>
                    <mx:VBox>
                        <mx:Image source="{data.image}" />
                        <mx:Label text="{data.label}" />
                    </mx:VBox>
                </mx:Component>
            </mx:itemRenderer>
        </mx:TileList>
    </mx:HBox>
 
</mx:Application>

• Add the rpc.swc and framework.swc from your {FLEX_HOME}/frameworks/libs to you ptoject or .fla classpath


• Optional: If you are compiling an Actionscript Project in Flash Builder you'll also need the resource bundles for those swcs. So add also the rpc_rb.swc and framework_rb.swc from {FLEX_HOME}/frameworks/locale to your classpath.


• Look at the code below, the initializeRPC and registerClasses methods are what you need to make things work.

import mx.collections.ArrayCollection;
import mx.core.mx_internal;
import mx.logging.Log;
import mx.logging.targets.TraceTarget;
import mx.messaging.ChannelSet;
import mx.messaging.channels.AMFChannel;
import mx.messaging.config.ConfigMap;
import mx.messaging.config.LoaderConfig;
import mx.messaging.messages.AcknowledgeMessage;
import mx.messaging.messages.AcknowledgeMessageExt;
import mx.messaging.messages.CommandMessage;
import mx.messaging.messages.CommandMessageExt;
import mx.messaging.messages.ErrorMessage;
import mx.messaging.messages.RemotingMessage;
import mx.rpc.AbstractOperation;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import mx.rpc.remoting.RemoteObject;
import mx.utils.ObjectProxy;

use namespace mx_internal;

const ID:String = "my-amf";
const ENDPOINT:String = "http://your.domain/amf/gateway";
const DEFAULT_SOURCE:String = "your.service";
const DEFAULT_SOURCE:String = "your.service";

var remoteObject:RemoteObject;

/**
 * This initializes the rpc library.
 * After this you should see the requests going through.
 * Note: LoaderConfig won't show up in the code hints, so you have to write down the import manually.
 */
function initializeRPC():void {
	
	LoaderConfig.mx_internal::_url = loaderInfo.url; 
	LoaderConfig.mx_internal::_parameters = loaderInfo.parameters;
}

/**
 * We register a bunch of class aliases that are needed by the rpc methods.
 * The list *may be* incomplete, if you get some TypeCoertion error try registering that class.
 */
function registerClasses():void {
	
	registerClassAlias("flex.messaging.messages.ErrorMessage", ErrorMessage);
	registerClassAlias("flex.messaging.messages.CommandMessage", CommandMessage);
	registerClassAlias("flex.messaging.messages.RemotingMessage", RemotingMessage);
	registerClassAlias("flex.messaging.messages.AcknowledgeMessage", AcknowledgeMessage);
	registerClassAlias("DSC", CommandMessageExt);
	registerClassAlias("DSK", AcknowledgeMessageExt);
	registerClassAlias("flex.messaging.config.ConfigMap", ConfigMap);
	registerClassAlias("flex.messaging.io.ObjectProxy", ObjectProxy);
	registerClassAlias("flex.messaging.io.ArrayCollection", ArrayCollection);
}

/**
 * Prepare the RemoteObject, creating the appropriate AMF channel
 * and setting up the default event handlers.
 */
function prepareDefaultRemoteObject():void {
	
	var channel:AMFChannel = new AMFChannel(ID, ENDPOINT);
	
	var channelSet:ChannelSet = new ChannelSet();
	channelSet.addChannel(channel);

	remoteObject = new RemoteObject();
	remoteObject.source = DEFAULT_SOURCE;
	remoteObject.destination = DEFAULT_DESTINATION;
	remoteObject.channelSet = channelSet;
	remoteObject.addEventListener(FaultEvent.FAULT, onDefaultServiceFault);
	remoteObject.addEventListener(ResultEvent.RESULT, onDefaultServiceResult);
}

/**
 * Create and execute the remote method.
 */
function makeAnonymousRemoteCall():void {
	
	var operation:AbstractOperation = ro.getOperation("getProduct");
	operation.send();
}


/**
 * Handles faulty replies from the remote methods.
 */
function onDefaultServiceFault(event:FaultEvent):void {
	
	trace(event.fault.faultDetail);
}

/**
 * Handles successful replies from the remote methods.
 */
function onDefaultServiceResult(event:ResultEvent):void {
	
	trace(event.result.toString());
}

// All RPC classes use the Flex logging API so enabling it in the Flash project could be helpful.
Log.addTarget(new TraceTarget());

initializeRPC();
registerClasses();

prepareDefaultRemoteObject();
makeAnonymousRemoteCall();

public function binarySearch(keys:Array, target:int):int
{
	var high:int = keys.length;
	var low:int = -1;
 
	while (high - low > 1)
	{
		var probe:int = (low + high) >>> 1;
		if (keys[probe] > target)
		{
			high = probe;
		}
		else
		{
			low = probe;
		}
	}
 
	return (low == -1 || keys[low] !== target) ? -1 : low;
}

override protected function childrenCreated():void{
	
	super.childrenCreated();
	
	if(!btn){
	
		btn = new Button();
		btn.label = "my as button";
		addChild(btn);
	
	}

}

var angle:Number = 0
var centerX:Number = 50
var centerY:Number = 50;
var radius:Number = 22;
var speed:Number = 0.1
 
var circle:Shape = new Shape();
addChild(circle)
circle.graphics.beginFill(0x00FF00);
circle.graphics.moveTo(centerX, centerY);
 
function onEnterFrame(e:Event) {
 
 if (angle > 2 * Math.PI)
  this.removeEventListener(Event.ENTER_FRAME, onEnterFrame)
 
 trace("angle", angle)
 circle.graphics.lineTo(centerX + Math.cos(angle) * radius,
             centerY + Math.sin(angle) * radius);
 
 angle += speed;
}
this.addEventListener(Event.ENTER_FRAME, onEnterFrame)

function duplicateDisplayObject(target:DisplayObject):DisplayObject {
        
       // create duplicate
        var targetClass:Class = Object(target).constructor;
        var duplicate:DisplayObject = new targetClass();
        
        // duplicate transformation properties
        duplicate.transform = target.transform;
        duplicate.filters = target.filters;
        duplicate.cacheAsBitmap = target.cacheAsBitmap;
        duplicate.opaqueBackground = target.opaqueBackground;
        
        // Check the scale9
        if (target.scale9Grid) {
           
            var rectangle:Rectangle = target.scale9Grid;           
            duplicate.scale9Grid = rectangle;

        }
       
        return duplicate;
    }

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
	
	<mx:Script>
		<![CDATA[
			import com.gnstudio.nabiro.ui.images.utils.OutputLevels;
			import mx.events.SliderEvent;
			
			private var bmd:BitmapData;
			
			override protected function childrenCreated():void{
				
				super.childrenCreated();
				
				var url:URLRequest = new URLRequest("central_park.jpg")
				
				var loader:Loader = new Loader();
				loader.contentLoaderInfo.addEventListener(Event.COMPLETE, imageCompleted);
				
				loader.load(url);
				
			}
			
			
			private function imageCompleted(e:Event):void{
				
				e.target.removeEventListener(e.type, arguments.callee);
				
				bmd = Bitmap(e.currentTarget.content).bitmapData;
				
				var output:OutputLevels = new OutputLevels(100);
				image.source = new Bitmap(output.setLevels(bmd.clone(), 0, 200));
				
			}
			
			private function outputLevels(e:SliderEvent):void{
				
				var output:OutputLevels = new OutputLevels(e.target.values[0] + (e.target.values[1] - e.target.values[0]) / 2);
				image.source = new Bitmap(output.setLevels(bmd.clone(), e.target.values[0], e.target.values[1]));
				
			}
			
		]]>
	</mx:Script>
	
	<mx:Image id="image" verticalAlign="middle" complete="imageCompleted(event)" horizontalAlign="center"  left="30" right="30" top="30" bottom="30"/>
	<mx:HSlider bottom="5" right="30" left="30" minimum="0" maximum="255" thumbCount="2" values="[0, 255]" liveDragging="false" change="outputLevels(event)" />

// these two code files show how to load a sample image using xml message generated from php


// as3, TryB64php.as

/**
 * @author jaco
 *
 * created on 16/10/2009 16.56.51
 */
package {

	import flash.display.*;
	import flash.events.*;
	import flash.text.*;
	import flash.net.*;
	import flash.geom.*;
	import flash.utils.*;

	// as3, got from http://dynamicflash.com/goodies/base64/
	// if you're in flex/air, there are mx.utils.Base64* classes
	import com.dynamicflash.util.Base64;


	/**
	 *
	 */
	public class TryB64php extends MovieClip {

		private static const PHP_URL:String = "get_xml_b64response.php";

		private var ul:URLLoader;
		private var ld:Loader;

		/**
		 * the constructor
		 */
		function TryB64php(){

			var ur:URLRequest = new URLRequest(PHP_URL);
			ld = new Loader();
			ul = new URLLoader();

			addChild(ld);

			ul.addEventListener(Event.COMPLETE, onULComplete);
			ul.load(ur);
		}

		private function onULComplete(evt:Event):void {

			var xml:XML = XML(ul.data);

			var ba:ByteArray = Base64.decodeToByteArray(xml);
			ld.loadBytes(ba);
		}
	}
}


// php, get_xml_b64response.php

<?php
/*
 * Created on 16/ott/2009
 *
 * jaco_at_pixeldump
 */

define("XML_HEADER", "<?xml version=\"1.0\"?>");
define("NL", "\r\n");

define("RESPONSE_INFO", "info");
define("RESPONSE_VALUE_BASE64", "base64");

/**
 * read resource from path
 * @param file name
 * @param directory
 *
 * @return xml instance with base64 encoded data
 */
function get_resource($resFN, $resDir = "./") {

	$filePath = $resDir .$resFN;
	$fRes = file_get_contents($filePath, FILE_BINARY);

	return create_simpleXmlMessage(base64_encode($fRes), RESPONSE_VALUE_BASE64);
}

/**
 * create an xml message
 * @param message string
 * @param response type
 *
 * @return formatted xml instance with given data
 */
function create_simpleXmlMessage($str, $type = RESPONSE_INFO) {

	$xmlStr = XML_HEADER .NL;
	$xmlStr .= create_xmlNode("response", $str, array("type" => $type, "timeStamp" => mktime()));

	return $xmlStr;
}

/**
 * create a simple xml node with some data population
 * @param node name
 * @param node content
 * @param attributes
 * @param CDATA flag
 *
 * @return formatted xml node with given data
 */
function create_xmlNode($nodeName, $nodeContent = "", $attrs = array(), $cDataFlag = true){

	$xmlStr = "<" .$nodeName ." ";
	$sfx1 = $cDataFlag ? "<![CDATA[" : "";
	$sfx2 = $cDataFlag ? "]]>" : "";

	if(count($attrs))
		foreach($attrs as $k => $v) $xmlStr .= $k ."=\"" .$v ."\" " ;

	if(strlen($nodeContent)){
		$xmlStr .= ">" .$sfx1 .$nodeContent .$sfx2;
		$xmlStr .= "</" .$nodeName .">";
	}
	else $xmlStr .= "/>";

	return $xmlStr;
}

// the app

header("Content-type: text/xml");
echo get_resource("sample_avatar.png"); // sample image
?>

var collection:ArrayCollection = new ArrayCollection();

collection.addItem({bar:"bar1", foo:1});
collection.addItem({bar:"bar2", foo:2});
collection.addItem({bar:"bar3", foo:3});
collection.addItem({bar:"bar4", foo:4});

var sort:Sort = new Sort();
sort.fields = [new SortField("foo")];

collection.sort = sort;
collection.refresh();

collection.addEventListener(CollectionEvent.COLLECTION_CHANGE, function(e:CollectionEvent):void {
	
	trace(e.type);
	
});

collection.disableAutoUpdate();
			
var cursor:IViewCursor = collection.createCursor();

while (!cursor.afterLast) {
	
	cursor.current.foo++;
	
	cursor.view.itemUpdated(cursor.current);
	
	cursor.moveNext();
	
}

collection.enableAutoUpdate();

var start:Date = new Date()
			
var startCounter:int = 1;
start.setMonth(3, startCounter);
			
for(var i:int = 0; i < 10; i++){
				
    startCounter++
    start.setMonth(3, startCounter)
				
    if(start.getDay() == 0){
					
	 break;
					
    }
				
}
			
var end:Date = new Date();
var endCounter:int = 31;
			
end.setMonth(3, endCounter);
			
for(var j:int = 0; j < 10; j++){
				
    endCounter--;
    end.setMonth(9, endCounter)
				
    if(end.getDay() == 0){
					
        break;
					
     }
				
}
			
trace("start date", start)
trace("end date", end)

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical"
	backgroundColor="#999999">

	<mx:Script>
		<![CDATA[
			
			// The Custom Image for the Slider Thumb 
			[Embed(source="assets/slider/slider_arrow.png")]
	    		public static const SLIDER_ARROW:Class;
	    
		]]>
	</mx:Script>
	
	
	
	<!--  STANDARD SLIDER  --> 
	<mx:HSlider width="100" height="1"
	 			 liveDragging="true"
	 			 />			
	 			 
	<mx:Spacer height="70" />
	
	
	<!--  SLIDER  WITH CUSTOM SKINS  --> 
	<mx:HSlider width="100" height="1"
	 			 trackSkin="skins.IconSliderTrack"
	 			 thumbSkin="{SLIDER_ARROW}"
	 			 sliderThumbClass="skins.IconSliderThumb"
	 			 liveDragging="true"
	 			 />
	
	
</mx:Application>



//==============================================================================
//skins/IconSliderTrack.as
//==============================================================================
package skins
{   
    import mx.core.UIComponent;   
  
    public class IconSliderTrack extends UIComponent   
    {   
           
        /**
        * Modify the default track layout
        * 
        */
        override protected function updateDisplayList(unscaledWidth:Number,
unscaledHeight:Number):void{   
            super.updateDisplayList(unscaledWidth, unscaledHeight);   
  			this.graphics.moveTo(0,0);   
            this.graphics.lineStyle(5,0x656565);   
	        
	        // Draw a curve instead of the classic line 
	      	this.graphics.curveTo(unscaledWidth, 40, unscaledWidth, 0)
	        
	        // Draw a Bold Line 
	        // NOTE: if you want to use this comment the previous line 
	        //this.graphics.lineTo(unscaledWidth,0);
	        
        }   
    }   
} 


//==============================================================================
//skins/IconSliderThumb.as
//==============================================================================
package skins {
	
    import mx.controls.sliderClasses.SliderThumb;

    public class IconSliderThumb extends SliderThumb {
        
        public function IconSliderThumb() {
            super();
            
            /**
            *  You need to manually update the thumb width 
            *  and height to the Thumg image dimensions,
            *  otherwise its displayed size won't be right.
            *  NOTE: try to comment following line to see the result 
            */             
            this.width = 36;
            this.height = 35;
            this.buttonMode = true;
        }
    }
}

<?xml version="1.0"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" xmlns:maps="com.google.maps.*" 
	layout="absolute" 
	width="100%" height="100%" >
  

   <mx:Script>
       <![CDATA[
       	import mx.events.ListEvent;
        import com.google.maps.interfaces.IPolyline;
        import com.google.maps.Map;
        import com.google.maps.MapEvent;
        import com.google.maps.LatLng;
        import com.google.maps.LatLngBounds;
        import com.google.maps.overlays.Marker;
        import com.google.maps.overlays.MarkerOptions;
        import com.google.maps.controls.ControlPosition;
        import com.google.maps.controls.MapTypeControl;
        import com.google.maps.services.*;
        import com.google.maps.MapAction;
        
        import mx.controls.Alert;
        import mx.collections.ArrayCollection;
            
        private var dir:Directions;
        
        
        /**
        * This method is called when the default Map is loaded 
        * 
        */
        private function onMapReady(event:Event):void {
            setupDirections();
            controlPanel.enabled = true;
        }
        
        /**
        * Define Direction class and its listeners 
        * 
        */
        private function setupDirections():void {    
        	
            dir = new Directions();
            dir.addEventListener(DirectionsEvent.DIRECTIONS_SUCCESS, onDirLoad);
            dir.addEventListener(DirectionsEvent.DIRECTIONS_FAILURE, onDirFail);
        }
        
        
        /**
        * Start a GMap Call to get distance between the selected store city and the user city 
        * 
        */
        private function processForm(event:ListEvent=null):void {
        	
        	// Set Directions Options (see GMAP API doc for properties details)
            var opts:DirectionsOptions = new DirectionsOptions({locale: "English", travelMode: "driving", avoidHighways: false})
            dir.setOptions(opts);
            
            // GMAP Query: From ... To ... 
            dir.load("from: " + from.text + " to: " + storeCities.selectedItem.data);
            
            // Disable query panel
            controlPanel.enabled = false;
        }
            
        /**
        * Direction Wrong Query (i.e. a city wasn't found in the db)  
        * 
        */
        private function onDirFail(event:DirectionsEvent):void {
              Alert.show("Status: " + event.directions.status);
              controlPanel.enabled = true;
        }
        
        /**
        * Direction Query SUCCESSFULLY   
        * 
        */
        private function onDirLoad(event:DirectionsEvent):void {
        	
        	// Enable Query Panel
        	controlPanel.enabled = true;
        	
        	// Get Direction object
            var dir:Directions = event.directions;
            
            // Clear previous displayed directions 
            map.clearOverlays(); 
            
            // Display Directions on Map
            var directionsPolyline:IPolyline = dir.createPolyline();
            map.addOverlay(directionsPolyline);
            var directionsBounds:LatLngBounds = directionsPolyline.getLatLngBounds();
            
            // Fix map position
            map.setCenter(directionsBounds.getCenter());
            map.setZoom(map.getBoundsZoomLevel(directionsBounds));
       
       		// Display Markers (start and destination) 
            var numRoutes:Number = dir.numRoutes;
            var startLatLng:LatLng = dir.getRoute(0).getStep(0).latLng;
            var endLatLng:LatLng = dir.getRoute(numRoutes-1).endLatLng;
            map.addOverlay(new Marker(startLatLng));
            map.addOverlay(new Marker(endLatLng));
            
            // Display trip info
            infoTripTxt.htmlText = dir.summaryHtml;
        }
            
        

       ]]>
   </mx:Script>
   
   
   <!--DEBUG KEY: you need to sign up for your own key-->
   <maps:Map 
    id="map" 
    key="ABQIAAAA7QUChpcnvnmXxsjC7s1fCxQGj0PqsCtxKvarsoS-iqLdqZSKfxTd7Xf-2rEc_PC9o8IsJde80Wnj4g" 
    mapevent_mapready="onMapReady(event)"
    width="100%" height="100%"/>

    
 
   <mx:VBox width="395" height="200" id="controlPanel" enabled="false"
 		backgroundAlpha="0.8" backgroundColor="#FFFFFF">
 		
	  <mx:HBox width="100%">
		   <mx:Label text="From (write your city):" fontWeight="bold"/>
		   <mx:TextInput
		     id="from"
		     text="Firenze"
		     width="100%" />
	  </mx:HBox>
	  
	  <mx:HRule width="100%" />
	  
	  <mx:Label fontWeight="bold"
		  text="To (select below the store and check the distance):"/>
			
	  	<mx:HBox width="100%" height="100%" verticalAlign="middle">
		    <mx:List id="storeCities" width="150"
		    	change="processForm(event)" height="121"> 
		        <mx:Object label="Milan - Outlet" data="Milan" />
		        <mx:Object label="Rome - Boutique" data="Rome" />
		        <mx:Object label="Napoli - Outlet" data="Napoli" />
		        <mx:Object label="Venezia - Shop" data="Venezia" />
		        <mx:Object label="Torino - Outlet" data="Torino" />
		    </mx:List>
		    
		    <mx:TextArea width="220" height="60" fontSize="14" id="infoTripTxt" 
		    	backgroundAlpha="0" borderStyle="none"/>	
		    
		</mx:HBox>

  </mx:VBox>

   
</mx:Application>

package {
	import flash.display.*;
	import flash.events.*;
	import flash.filters.BlurFilter;
	import flash.geom.ColorTransform;
	import flash.text.TextField;
	import flash.utils.getDefinitionByName;

	import com.flashdynamix.motion.*;
	import com.flashdynamix.motion.effects.*;
	import com.flashdynamix.motion.extras.Emitter;
	import com.flashdynamix.motion.layers.BitmapLayer;


	public class MenuEmitter extends Sprite {

		
		public var menuButton:MovieClip;

		private var emittor : Emitter;
		private var layer : BitmapLayer;
		
		private var ct : ColorTransform;
		private var bf : BlurFilter;

		private var tx : Number;
		private var ty : Number;

		public function MenuEmitter() {
			
	
			// Create a Bitmap Layer where we'll draw the Emitter and apply some effects
			layer = new BitmapLayer(900, 400);
			bf = new BlurFilter(10, 10, 2);
			layer.add(new ColorEffect(new ColorTransform(1, 1, 1, 0.9)));
			layer.add(new FilterEffect(bf));
			
			// Set quality to LOW to get better performance
			stage.quality = StageQuality.LOW;
			
			
			// The Emitter MovieClip "BluePrint"
			var Box : Class = getDefinitionByName("Box") as Class;
			
			// Emitter Creation
			ct = new ColorTransform(1, 1, 1, 1, -115, -30, 70);
			emittor = new Emitter(Box, null, 2, 1, "0, 360", "1, 110", 1, BlendMode.ADD);
			emittor.transform.colorTransform = ct;
			emittor.endColor = {redOffset:255, greenOffset:-10, blueOffset:-270, alphaOffset:-255};
			
			// We can't build the emitter on 0,0 because it will be cutted on the top and on the left side
			emittor.x = 150
			emittor.y = 150
			
			// Display on screen
			layer.draw(emittor.holder);
			menuButton.addChildAt(layer,0);
			
			// Stop emitter at startTime
			emittor.stop()

			// RollOver / RollOut on button
			menuButton.gfx.buttonMode = true;
			menuButton.gfx.addEventListener(MouseEvent.ROLL_OVER, onMenuRollOver)
			menuButton.gfx.addEventListener(MouseEvent.ROLL_OUT, onMenuRollOut)
			
			// ENTER_FRAME event
			// We'll update the emittor properties to generate random
			addEventListener(Event.ENTER_FRAME, update)
			
		}
		
		/**
		* Update emittor rotation properties to have different rotation for each particle
		*/
		private function update(e : Event) : void {
			emittor.rotation += 20;
		}
		
		/**
		* At Button rollOver start the emitter
		*/
		private function onMenuRollOver(e : MouseEvent) : void {
			emittor.start()
		}
		
		/**
		* At Button rollOut stop the emitter
		*/
		private function onMenuRollOut(e : MouseEvent) : void {
			emittor.stop()
		}
		
		
		
		

	}
}

package {
	
	import flash.display.MovieClip;
	import flash.display.Stage;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display.StageDisplayState
	
	import fl.controls.Button;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.events.FullScreenEvent;


	public class FullScreenMain extends MovieClip {
		
		// The FullScreen Button
		private var fullScreen_btn:Button;
		
		// Save the fullScreen status
		private var fullScreenStatus:Boolean;		
		
		
		/**
		* Constructor
		*/
		public function FullScreenMain() {

			// Create the FullScreen Button (add to the .fla library the button component assets)
			fullScreen_btn = new Button();
			fullScreen_btn.label = "Enable FULL_SCREEN";
			fullScreen_btn.width = 150;
			fullScreen_btn.x = 120;
			fullScreen_btn.y = 50;
			addChild(fullScreen_btn)


			// Set NO_SCALE because we don't want that when fullscreen is enable movieclips are scaled too
			var swfStage:Stage = this.stage;
			swfStage.scaleMode = StageScaleMode.NO_SCALE;
			swfStage.align = StageAlign.TOP_LEFT;
			
			// Registriamo un listener per la modalitÃÆ’Æ’ÃÆââ‚

¬â„¢ÃƒÆ’†â€™ÃƒÂ¢Ã¢â€šÂ¬ ââ‚Ãââ‚

¬Å¡Ãƒâ€šÃ‚¬ÃƒÆ’¢â€žÂ¢  FULLSCREEN:

			// Listener for FullScreen Button
			fullScreen_btn.addEventListener(MouseEvent.CLICK, changefullScreenStatus)


			// Listener for FullScreen event. It's invoked every time the 'displayState' property change
			fullScreen_btn.stage.addEventListener(FullScreenEvent.FULL_SCREEN, fullScreenRedraw);
			

		}



	
	
		/**
		* Check the fullScreenStatus and Enabled / Disable the FullScreen
		*/
		private function changefullScreenStatus(e:MouseEvent):void 
		{
			// Disable FullScreen if enabled, and viceversa
			if(fullScreenStatus)
				fullScreen_btn.stage.displayState = StageDisplayState.NORMAL;
			else
				fullScreen_btn.stage.displayState = StageDisplayState.FULL_SCREEN;
				
		
		}
		
		/*
		* Invoked at every 'displayState' property change
		*/
		function fullScreenRedraw(event:FullScreenEvent):void
		{
			// Check if fullScreen is enabled and uptades properties
			if (event.fullScreen)
			{
				fullScreen_btn.label = "Disable FULL_SCREEN";
				fullScreenStatus = true;
			}
			else
			{
				fullScreen_btn.label = "Enable FULL_SCREEN";
				fullScreenStatus = false;
			}
		
		}
		
	
	}
}

// FLASH DOCUMENT CLASS
package {

	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.MouseEvent;
	import caurina.transitions.*
	import flash.display.DisplayObject;
	
	public class VideoMain extends Sprite
	{
		
		// Horizontal Gap between Video Thumbs
		private const HORIZONTAL_GAP:uint = 50;
		
		// Total of VideoThumbs to show
		private const VIDEO_TOTAL:uint = 6;
		
		// Thumbnails original Y position
		private const Y_POS:uint = 125;

		// Thumbnails original Z position
		private const Z_POS:uint = 550;
		
	
		
		public function VideoMain()
		{
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			
			
			// Create video thumbs
			for (var i:uint = 0; i < VIDEO_TOTAL; i++) {
				
				// Create a new VideoThumb istance 
				var thumb:VideoThumb = new VideoThumb();
				
				// Save original Index VideoThumb 
				thumb.originalIndex = i;
				
				// Set Thumb Position (x, y, z)
				thumb.x = thumb.originalX = HORIZONTAL_GAP * i 
				thumb.y = Y_POS
				thumb.z = Z_POS;
				
				// Set Thumb Rotation
				thumb.rotationY = -90;

				thumb.addEventListener(MouseEvent.CLICK, onClick)
				thumb.buttonMode = true;
				
				addChild(thumb)
			}
		}
		
		

		/**
		* Click Video MovieClip
		*/
		private function onClick(event:MouseEvent):void
		{
			// If clicked videoThumb is already opened
			if(event.currentTarget.isOpened) {
				
				// Back to the original position				
				Tweener.addTween(event.currentTarget, {
									   rotationY: -90 , 
							 		   x: event.currentTarget.originalX,
									   y: Y_POS,
									   z: Z_POS,									   
									   time:0.5, 
									   transition:"easeInOutSine",
									   onComplete: event.currentTarget.videoFLB.stop()});
			

				// Set depth to the original Position
				this.swapChildrenAt(getChildIndex(event.currentTarget as DisplayObject), event.currentTarget.originalIndex)
				
				
				
			} else {

				// Enlarge Video and PLay it when animation is completed
				Tweener.addTween(event.currentTarget, {
							 		   rotationY: 0 , 
							 		   x: 230,
									   y: 200,
									   z: 0,
									   rotationY: 0,
									   time:0.5, 
									   transition:"easeInOutSine",
									   onComplete: event.currentTarget.videoFLB.play()});

				// Bring to Front				
				this.swapChildrenAt(event.currentTarget.originalIndex, this.numChildren -1 )
				
			}
			
			
			// Change isOpened Status (to always know if a thumb is opened ) 
			event.currentTarget.isOpened = !event.currentTarget.isOpened;
			
		}
		
		
	}
}





// VideoThumb.as Class
package {


	import flash.display.MovieClip;

	
	public class VideoThumb extends MovieClip
	{
		
		private var _originalIndex:Number ;
		private var _originalX:Number ;
		private var _isOpened:Boolean = false;
		
		
		/**
		* Constructor
		*/
		public function VideoThumb(){}
		
		
		/**
		* Original Index position (usefull to know the Thumb depth)
		*/
		public function set originalIndex(val:Number):void {
			_originalIndex = val;			
		}
		
		public function get originalX():Number {
			return _originalX ;			
		}
		
		
		
		
		/**
		* Original x position (usefull to position Thumb to the original Position)
		*/
		public function set originalX(val:Number):void {
			_originalX = val;			
		}
		
		
		public function get originalIndex():Number {
			return _originalIndex ;			
		}
		
		
		
		
		/**
		* If the VideoThumb is opened or not
		*/
		public function set isOpened(val:Boolean):void {
			_isOpened = val;			
		}
				
		
		public function get isOpened():Boolean {
			return _isOpened ;			
		}
		
		
	}
}