package
{
	public class ClaseB
	{
		public var atributoB:Number;	
		public function ClaseB()
		{
		}
	}
}

package
{
	public class ClaseA
	{
		public var atributoA:ClaseB;
		public function ClaseA(atributo:ClaseB){
			atributoA = atributo;
		}
	}
}

package {
	import flash.display.Sprite;
 
	public class ReferenciaValorTest extends Sprite
	{
		/**
		 * @autor Alejandro Sánchez
		 * http://www.electroduendes.com/blog/
		 * */
		public function ReferenciaValorTest()
		{
			var b:ClaseB = new ClaseB();
			b.atributoB = 10;
			trace(b.atributoB) // OUTPUT: 10
 
			var a:ClaseA = new ClaseA(b);
			trace(a.atributoA.atributoB) // OUTPUT: 10
 
			a.atributoA.atributoB = 5;
			trace(a.atributoA.atributoB) // OUTPUT: 5
			trace(b.atributoB) // OUTPUT: 5
 
			b.atributoB = 10;
			trace(a.atributoA.atributoB) // OUTPUT: 10
			trace(b.atributoB) // OUTPUT: 10
 
			var c:Number = 20;
			a.atributoA.atributoB = c			
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 20
 
			c = 30;
			trace(a.atributoA.atributoB); // OUTPUT: 20
			trace(b.atributoB); // OUTPUT: 20
			trace(c); // OUTPUT 30
 
		}
	}
}

miMc.parent.removeChild(miMc)

DisplayObjectTerminator.remove(miMc)

/**
 * written by evride //
 * Actionscript.org forums user //
 * found a problem? tell me there //
 */
package com.evride{
	public class RemoveObject {
		public static  function remove(obj:Object) {
			if (obj) {
				if (obj is DisplayObject) {
					if (obj.parent) {
						try {
							obj.parent.removeChild(obj);
						} catch (e:Error) {
							trace("Couldn't remove the object. It wasn't a child of a DisplayObject.");
						}
					} else {
						trace("Couldn't remove object. Parent property is null.");
					}
				} else {
					trace("Couldn't remove object. It is not a DisplayObject.");
				}
			} else {
				trace("Couldn't remove the object. It was null or doesn't exist.");
			}
		}
	}
 
}

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();
	}
}