import com.gskinner.events.GDispatcher;
import mx.utils.Delegate;
/**
 * @author Álex Sánchez
 * http://www.electroduendes.com/
 * @version 1.1
 * @usage  Clase para cargar Jpgs o swfs en un contenedor en serie (una detrás
 * de otra). Suele ser útil para galerías de imágenes.
 * 
 * listeners:
 * 	- onLoadProgress; devuelve un objeto del tipo:
 * 	{type:"onLoadProgress", mc:MovieClip, progress:Number, total:Number, percent:Number};
 * 	
 * 	- onLoadActualStart; devuelve un objeto del tipo:
 * 	{type:"onLoadActualStart", mc:MovieClip}
 * 	
 * 	- onLoadActualComplete; devuelve un objeto del tipo:
 *  {type:"onLoadActualComplete", mc:MovieClip}
 * 	
 * 	- onLoadAllComplete; devuelve un objeto del tipo:
 * 	{type:"onLoadAllComplete"}
 * 	
 * <code>
 * 		import com.electroduendes.precarga.PrecargaSerie;
 * 		import mx.utils.Delegate;
 * 		
 * 		var precarga:PrecargaSerie = new PrecargaSerie();
 * 		var urls:Array = new Array("1.jpg", "2.jpg", "3.jpg", "4.jpg");
 * 		var clips:Array = new Array(_root.uno, 
 * 			_root.dos, _root.tres, _root.cuatro);
 * 		precarga.addEventListener("onLoadProgress", 
 * 			Delegate.create(this, progreso));
 * 		precarga.addEventListener("onLoadActualComplete", 
 * 			Delegate.create(this, fincarga));
 * 		precarga.addEventListener("onLoadAllComplete", 
 * 			Delegate.create(this, fintodo));
 * 		precarga.addEventListener("onLoadActualStart", 
 * 			Delegate.create(this, inicioCarga));
 * 		precarga.loadClips(urls, clips);
 * 		
 * 		function progreso(obj) {
 * 			trace("progreso despachado para mc "+obj.mc+ " al : "+obj.percent+"%");
 * 		}
 * 		function inicioCarga(obj){
 * 			trace("inicio de carga para el mc"+obj.mc);
 * 		}
 * 		function fincarga(obj) {
 * 			trace("fincarga despachada para movieclip: "+obj.mc);
 * 		}
 * 		
 * 		function fintodo() {
 * 			trace("fintodo despachado");
 * 		}	
 * </code>
 */
class com.electroduendes.precarga.PrecargaSerie {
 
	private var numCargados:Number = 0;
	// número de objetos que ya están cargados
	private var actualProgress:Number = 0;
	// almacena el progreso de carga
	private var actualTotal:Number = 0;
	private var actualPercent:Number = 0;
	private var actualTarget:MovieClip = null;
	private var urlArray : Array;
	private var targetArray : Array;
	private var interval:Number = 0;
	var dispatchEvent:Function;
	var addEventListener:Function;
	var removeEventListener:Function;
	function PrecargaSerie(){
		GDispatcher.initialize(this);
	}
	/*
	 * inicia el proceso de carga
	 * @param urlArray el arrray de películas a cargar
	 * @param targetArray el array de contenedores (movieclips)
	 */
	function loadClips(urlArray:Array, targetArray:Array, type:String) {
 
			this.urlArray = urlArray;
			this.targetArray = targetArray;
			load();
	}
	/**
	* efectua el loadMovie. 
	* se va a ejecutar 'n veces' tantas como numCargados.
	*/
	private function load():Void {
		targetArray[numCargados].loadMovie(urlArray[numCargados]);
		// con el setInterval, nos aseguramos de que actualProgress sea > 0
		// guardamos la referencia actual en el atributo actualTarget
		actualTarget = targetArray[numCargados];
		interval = setInterval(Delegate.create(this, loadStart), 50);
	}
	/**
	* permite saber si la carga está iniciada
	* se usa porque la carga no devuelve 0 hasta que no se comienza a cargar
	*/
	private function loadStart():Void {
		actualProgress = targetArray[numCargados].getBytesLoaded();
		// si ya ha empezado a cargar...
		if (actualProgress>=0) {
			// limpiamos esta funcion
			clearInterval(interval);
			onLoadActualStart();
			// con esto conseguimos que actualProgress siempre esté actualizado
			interval = setInterval(Delegate.create(this,onLoadProgress), 50);
		}
	}
	/**
	* permite escuchar el porcentaje de la carga 
	* actualiza las propiedades tales como actualProgress, actualPercent.
	*/
	private function onLoadProgress():Void {
		actualProgress = actualTarget.getBytesLoaded();
		actualTotal = actualTarget.getBytesTotal();
		actualPercent = Math.round((actualProgress*100)/actualTotal);
 
		var eventObj:Object = { type:"onLoadProgress", 
					mc:MovieClip, 
					progress:Number, 
					total:Number,
					percent:Number
					};
		eventObj.mc = actualTarget;
		eventObj.progress = actualProgress;
		eventObj.total = actualTotal;
		eventObj.percent = actualPercent;
 
	  	//despacho evento para los preloaders
	  	dispatchEvent(eventObj);
		if (actualPercent>=100) {
			clearInterval(interval);
			actualProgress = 0;
			numCargados++;
			onLoadActualComplete(actualTarget);
			if (numCargados<targetarray .length) {
				load();
			} else {
				//acabamos!
				onLoadAllComplete();
			}
		}
	}
	/**
	* función que se ejecutará cuando empiece la precarga de
	* algún objeto
	* @param ref 
	* una referencia del objeto que se ha cargado
	*/
	public function onLoadActualStart():Void {
		var eventObj:Object = {type:"onLoadActualStart", mc:MovieClip};
		eventObj.mc = actualTarget;
		dispatchEvent(eventObj);
	}
	/**
	*
	* @usage función que se ejecutará cuando termine la precarga de
	* algún objeto
	* @param ref 
	* una referencia del objeto que se ha cargado
	*/
	private function onLoadActualComplete(ref:Object):Void {
		var eventObj:Object = {type:"onLoadActualComplete", mc:Object};
	  	//despacho evento
	  	eventObj.mc = actualTarget;
	  	dispatchEvent(eventObj);		
	}
	/**
	*
	* @usage función que se ejecutará cuando termine la precarga de
	* de el último objeto a cargar
	*/
	private function onLoadAllComplete():Void {	
		var eventObj:Object = {type:"onLoadAllComplete"};
	  	//despacho evento
	  	dispatchEvent(eventObj);
	}
	/**
	* @usage getter target array 
	* los contenidos
	* @return un array de clips
	*/
	public function getTargetArray():Array {
		return targetArray.slice();
	}
}

import mx.utils.Delegate;
/**
 * @author Alejandro Sánchez Marcos
 * @usage
 import com.electroduendes.tween.BlurTween;
 var blurTween:BlurTween = new BlurTween(mc);
 var initBlur:Object = {blurX:0, blurY:0, quality:3};
 var finalBlur:Object = {blurX:50, blurY:5, quality:3};
 a.onRelease = function() {
 	blurTween.tween(initBlur, finalBlur, 1);
 };
 b.onRelease = function() {
 	blurTween.tween(finalBlur, initBlur, 1);
 };
*
*/
class com.electroduendes.tween.BlurTween {
 
	public var interval: Number = 40;
	private var filter:BlurFilter;
	private var blur_interval:Number;
	private var mc:MovieClip;
	private var quality : Number;
	private var counter : Number;
	private var iterations : Number;
	private var diferenceX:Number;
	private var diferenceY:Number;
 
	public function BlurTween(mc:MovieClip){
		this.mc = mc;
		filter = new BlurFilter();
	}
	public function tween(initBlur:Object, finalBlur:Object, seconds:Number) : Void {
		counter = 0;
		this.iterations = Math.ceil(seconds*1000/interval);
		// apply init blur
		filter.blurX = initBlur.blurX;
		filter.blurY = initBlur.blurY;
		filter.quality = initBlur.quality;
		mc.filters = [filter];
		// calculate difference
		diferenceX = finalBlur.blurX – initBlur.blurX;
		diferenceY = finalBlur.blurY – initBlur.blurY;
		this.quality = finalBlur.quality;
		// if we have something to blur or unblur…
		clearInterval(blur_interval);
		if (diferenceX!=0 && diferenceY!=0)
			blur_interval = setInterval(Delegate.create(this, applyTween), interval);
	}
	private function applyTween() : Void {
		counter++;
		filter.blurX += diferenceX/iterations;
		filter.blurY += diferenceY/iterations;
		filter.quality = quality;
		mc.filters = [filter];
		if (counter == iterations) clearInterval(blur_interval);
	}
}