package  com.actionscriptfacile.skin
{
 
	import com.actionscriptfacile.skin.ISkin;
 
	public interface ISkinnable
	{
 
		function applySkin( p_skin:ISkin ):void;
 
	}
 
}

package  com.actionscriptfacile.skin
{
 
	import com.actionscriptfacile.skin.ISkin;
	import flash.utils.Dictionary;
	import flash.utils.getDefinitionByName;
	import flash.utils.getQualifiedClassName;
 
	public class Skin implements ISkin
	{
		private var m_data:Dictionary;
 
		public function Skin()
		{
			m_data = new Dictionary();
		}
 
		public function setSkin( p_skinName:String, p_skinDefinition:Class ):void
		{
			m_data[ p_skinName ] = p_skinDefinition;
		}
 
		public function getSkin(p_skinName:String) :Class
		{
			return m_data[ p_skinName ];
		}
 
		public function clone():ISkin
		{
			var definition:Class = getDefinitionByName( getQualifiedClassName( this ) ) as Class;
			var skin:ISkin = new definition() as ISkin;
			skin.setSkins( m_data );
 
			return skin;
		}
 
		public function setSkins(p_skins:Dictionary):void{ m_data = p_skins; }
		public function getSkins():Dictionary { return m_data; }
 
		public function destroy():void
		{
			m_data = null;
			delete this;
		}
 
	}
 
}

package  com.actionscriptfacile.skin
{
	import flash.utils.Dictionary;
 
	public interface ISkin
	{
		function setSkin( p_skinName:String, p_skinDefinition:Class ):void;
		function getSkin( p_skinName:String ):Class;
		function setSkins( p_skins:Dictionary ):void;
		function getSkins():Dictionary;
 
		function clone():ISkin;
 
		function destroy():void;
	}
 
}

package  com.actionscriptfacile.ui
{
	import com.actionscriptfacile.skin.ISkinnable;
	import flash.display.DisplayObjectContainer;
	import com.actionscriptfacile.ui.tooltip.Tooltip;
 
	public interface IComponent extends ISkinnable
	{
 
		function destroy():void;
		function hide():void;
		function show():void;
 
		function onAdded():void;
		function onRemoved():void;
 
		function onAddedToStage():void;
		function onRemovedFromStage():void;
 
		function resize( p_width:Number , p_height:Number ):void;
 
		function set tooltip( p_toolTip:Tooltip ):void;
		function get tooltip():Tooltip;
 
		function get lastParent():DisplayObjectContainer;
 
	}
 
}

package  com.actionscriptfacile.ui
{
	import com.actionscriptfacile.skin.ISkin;
	import com.actionscriptfacile.ui.tooltip.Tooltip;
	import flash.display.DisplayObject;
	import flash.display.DisplayObjectContainer;
	import flash.display.Sprite;
	import flash.events.Event;
	import com.actionscriptfacile.ui.IComponent;
	import flash.events.MouseEvent;
 
	/**
	 * Classe  de base de tous les composants
	 * @author Matthieu
	 */
 
	public class UIComponent extends Sprite implements IComponent
	{
 
		private var m_lastParent:DisplayObjectContainer; // Le dernier parent connu de l'objet
		private var m_tooltip:Tooltip; // Un objet de type Tooltip
 
		static public const RELEASE_OUTSIDE:String = 'RELEASE_OUTSIDE'; 
		// Constante utilisée pour les addEventListener
 
		/**
		 * Constructeur
		 */
 
		public function UIComponent()
		{
			m_lastParent = null;
			m_tooltip = null;
 
			addEventListener( Event.ADDED, addedHandler );
			addEventListener( Event.ADDED_TO_STAGE, addedHandler );
			addEventListener( Event.REMOVED, removeHandler );
			addEventListener( Event.REMOVED_FROM_STAGE, removeHandler );
			addEventListener( MouseEvent.MOUSE_DOWN, downUpHandler );
			addEventListener( MouseEvent.ROLL_OVER, overOutHandler );
			addEventListener( MouseEvent.ROLL_OUT, overOutHandler );
 
		}
 
		// events listeners
 
		/**
		 *
		 * Cette méthode est utilisée pour afficher / cacher le tooltip si celui-ci est défini.
		 *
		 * @param	e Un objet de type MouseEvent
		 */
		private function overOutHandler(e:MouseEvent):void
		{
			if ( m_tooltip == null )
			{
				return;
			}
 
			if ( e.type == MouseEvent.ROLL_OUT )
			{
				m_tooltip.hide();
			}
			else
			{
				m_tooltip.show();
			}
		}
 
		/**
		 * @private utilisée pour détecter les RELEASE OUTSIDE
		 * @param	e
		 */
		private function downUpHandler(e:MouseEvent):void
		{
 
			if ( e.type == MouseEvent.MOUSE_DOWN )
			{
 
				/*
				 * Si on appuie sur le click de la souris alors on cherche à détecter le moment
				 * ou on la relachera que l'on soit sur l'objet ou non.
				 *
				 * */
				stage.addEventListener( MouseEvent.MOUSE_UP, downUpHandler );
				stage.addEventListener( MouseEvent.MOUSE_UP, downUpHandler, true );
			}
			else
			{
 
				/*
				 * Si la souris est relâchée, nous n'avons plus besoin d'écouter les événements adéquats.
				 * Nous vérifions ensuite que la souris ne se trouvait pas sur le composant à ce moment là 
				 * et on dispatch un évenement.
				 * */
 
				stage.removeEventListener( MouseEvent.MOUSE_UP, downUpHandler );
				stage.removeEventListener( MouseEvent.MOUSE_UP, downUpHandler, true );
 
				if ( ! hitTestPoint( e.stageX, e.stageY , false ) )
				{
					dispatchEvent( new Event( RELEASE_OUTSIDE, true, true ) );
				}
 
			}
		}
 
		/**
		 *
		 * Détecte les évènements de type Event.ADDED et Event.ADDED_TO_STAGE et se charge d'appeler 
		 * les méthodes onAdded ou onAddedToStage.
		 *
		 * @param	e évènements de type Event
		 */
		private function addedHandler( e:Event ):void
		{
 
			if ( parent != null )
			{
				m_lastParent = parent;
			}
 
			if ( e.type == Event.ADDED )
			{
				onAdded();
			}
			else
			{
				onAddedToStage();
			}
		}
 
		/**
		 *
		 * Détecte les évènements de type Event.REMOVED et Event.REMOVED_FROM_STAGE et se charge d'appeler 
		 * les méthodes onRemoved ou onRemovedFromStage.
		 *
		 * @param	e évènements de type Event
		 */
		private function removeHandler( e:Event ):void
		{
 
			if ( parent != null )
			{
				m_lastParent = parent;
			}
 
			if ( e.type == Event.REMOVED )
			{
				onRemoved();
			}
			else
			{
				onRemovedFromStage();
			}
 
		}
 
		// fonctions publiques
 
		/**
		 * Détruit proprement le composant
		 */
 
		public function destroy():void
		{
 
			// on cherche à sortir de la display list du parent
 
			if ( parent != null && parent.contains( this ) )
			{
				parent.removeChild( this );
			}
 
			// on supprime proprement tous les objets de note display list
 
			while ( numChildren > 0 )
			{
				var child:DisplayObject = removeChildAt( 0 );
				child = null;
			}
 
			// on passe la propriété lastParent à null
			m_lastParent = null;
 
			// Enfin, on détruit tous les event listeners
 
			removeEventListener( Event.ADDED, addedHandler );
			removeEventListener( Event.ADDED_TO_STAGE, addedHandler );
			removeEventListener( Event.REMOVED, removeHandler );
			removeEventListener( Event.REMOVED_FROM_STAGE, removeHandler );
			removeEventListener( MouseEvent.MOUSE_DOWN, downUpHandler );
			removeEventListener( MouseEvent.ROLL_OVER, overOutHandler );
			removeEventListener( MouseEvent.ROLL_OUT, overOutHandler );
			stage.removeEventListener( MouseEvent.MOUSE_UP, downUpHandler );
			stage.removeEventListener( MouseEvent.MOUSE_UP, downUpHandler, true );
 
			delete this;
 
		}
 
		/**
		 * Supprime le composant de la display list de son lastParent
		 */
		public function hide():void
		{
 
			if ( parent != null && parent.contains( this ) )
			{
				m_lastParent = parent;
				parent.removeChild( this );
			}
		}
 
		/**
		 * Ajoute le composant à la display list de son lastParent
		 */
		public function show():void
		{
 
			visible = true;
 
			if ( m_lastParent == null )
				return;
 
			m_lastParent.addChild( this );
 
		}
 
		// fonctions destinées à être overridées
 
		/**
		 * Est éxécutée lorsque le composant est ajouté à la display list d'un DisplayObjectContainer, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 */
		public function onAdded():void { }
 
		/**
		 * Est éxécutée lorsque le composant est supprimé de la display list d'un DisplayObjectContainer, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 */
		public function onRemoved():void { }
 
		/**
		 * Est éxécutée lorsque le composant est ajouté à la display list du stage, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 */
		public function onAddedToStage():void { }
 
		/**
		 * Est éxécutée lorsque le composant est supprimé de la display list du stage, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 */
		public function onRemovedFromStage():void { }
 
		/**
		 * Fonction qui sert à réceptionner et appliquer une skin au composant, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 *
		 * @param	p_skin Objet qui implémente l'interface ISkin @see
		 */
		public function applySkin(p_skin:ISkin):void { }
 
		/**
		 * Fonction qui sert à changer la taille d'un composant de manière propre, 
		 * cette méthode prend tout son sens dans le cas d'un override.
		 *
		 * @param	p_width		nouvelle largeur du composant
		 * @param	p_height	nouvelle hauteur du composant
		 */
		public function resize(p_width:Number, p_height:Number):void
		{
 
		}
 
		// getters / setters
 
		/**
		 * Définit un objet de type Tooltip
		 */
		public function set tooltip(p_toolTip:Tooltip):void 
		{  m_tooltip = addChild( p_toolTip ) as Tooltip; m_tooltip.hide(); }
		/**
		 * Retourne le tooltip du composant
		 */
 
		 public function get tooltip():Tooltip { return m_tooltip; }
 
		/**
		 * Renvoie le dernier parent du composant.
		 */
		public function get lastParent():DisplayObjectContainer{ return m_lastParent; }
 
	}
 
}