CV
Langages
- C
- PHP
- Java
- Perl
- Ruby
- Javascript
- Flex 3
- Python
- GO
- C#
- TCL
- Bash
Liens
Articles
Contact

Adobe Flex

Expertise (5/5)

J'ai utilisé Adobe Flex 3 de façon intensive pendant 2 ans, pour développer des sites WEB en flash.

Actionscript est un excellent langage de développement. Et le framework d'Adobe est vraiment bien conçu et bien documenté.

Le présent document présente des extraits d'une librairie que j'ai développée pour un projet qui comportait des centaines de milliers de lignes de code en ActionScript. Il s'agissait d'un client riche qui dialoguait avec des serveurs développés PHP (sous framework ZEND).

Cela dit, je me suis tourné vers le Javascript, et vers JQuéry en particulier. L'intégration entre JavaScript et le document HTML est un avantage énorme.

Remarque : Je suis régulièrement contacté par des cabinets de placement qui me proposent des missions autour de Flex. Je ne suis pas intéressé pour travailler sur Flex. En France, la demande est faible, les salaires sont bas, et le métier de développeur Flex est une "voie de garage technologique".

Codes sources
Quelques interfaces
Quelques composants étendus
Quelques composants spéciaux
Quelques outils

Codes sources

Le lien ci-dessous pointe vers une librairie qui contient un certain nombre d'outils simples qui ont été utilisés dans le développement d'une très grosse application (que j'ai entièrement développé de A à Z) qui intègre :

Géolocalisation.
Référentiel géographique.
Interfaçage avec Google MAP
Chargement à la demande de fichier SWF.
Interconnexion avec un service développé en PHP (ZEND Framework).

framework.zip

Quelques interfaces

L'interface ci-dessous définit le concept d'acteur. Un acteur est un composant logiciel qui signale des changements d'états fonctionnels. Un acteur est désigné par son nom et on lui associe une liste d'états fonctionnels.
L'interface ci-dessous définit le concept de sélecteur. Il s'agit d'un élément interactif de sélection.

/* Author: Denis BEURIVE */

package interfaces
{
	/** Cette interface définit les composants de type "Selector".
	 *  Ce type de composant est utilisé pour sélectionner des valeurs.
	 *  Il peut aussi être initialisé à des valeurs de départ.
	 */
	
	public interface ISelectorInterface
	{
		/** Cette méthode renvoie les valeurs sélectionnées par l'utilisateur.
		 *  L'organisation de l'objet renvoyé dépend de la nature des informations sélectionnées.
		 */
		
		function getSelectedValues():Object;
		
		/** Cette méthode permet d'initialiser un composant de sélection avec des valeurs.
		 *  @param inValues Cet objet contient les valeurs utilisées pour l'initialisation du composant.
		 *  @param inDisparchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à la mise à jour de l'heure.
		 */
		
		function setValues(inValues:Object, inDispatchEvt:Boolean=true):void;
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		function enable():void;

		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		function disable():void;

		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         Chaque propriété de l'objet représente une propriété à réinitialiser.
		 */
		
		function reset(inValues:Object=null):void;
	}
}

L'interface ci-dessous définit le concept de sélecteur multiple.

/* Author: Denis BEURIVE */

package interfaces
{
	
	/** Cette interface définit un type de composant qui présente la particularité d'autoriser la sélection de plusieurs valeurs.
	 *  Par exemple : Un composant de type GeoPicker permet de sélectionner 3 valeurs :
	 *                o Région.
	 *                o Région + Département.
	 *                o Région + Département + Code postal.
	 *  Suivant le contexte (logique d'utilisation) dans lequel est utilisé ce composant, les critères d'interprétation des valeurs sélectionnées ne sont pas les mêmes.
	 *  Par exemple : Lorsque les trois valeurs géographiques (région, département, code postal) sont sélectionnées simultanément, cela signifie quelque chose de particulier pour vous.
	 *                Dans un autre contexte d'utilisation, la simultanéité de la sélection ne vous intéresse pas.
	 * 
	 *  Cette interface définit un ensemble de méthode qui permette d'injecter, dans le composant, du "code étranger" (correspondant à de la logique d'utilisation spécifique).
	 */
	
	public interface ICompositeActorInterface
	{
		/** Cette méthode permet de définir une fonction, qui sera exécutée par l'acteur, à chaque fois que ce dernier change d'état.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 *  @note Prototype de la fonction: inFunction(inData:Object=null):void
		 */
		
		function setOnModificationHandler(inFunction:Function=null):void;		
	}
}

Quelques composants étendus

Les classes ci-dessous implémentent des composants de sélection "étendus". Ces composants implémentent certaines interfaces telles que les interfaces d'acteurs ou de sélecteur.

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.collections.XMLListCollection;
	import mx.controls.ComboBox;
	import mx.events.FlexEvent;
	import mx.events.ListEvent;
	
	import tools.DataProviderTools;
	import tools.FunctionUtilities;

	/** Ce composant simplifie l'utilisation de la liste déroulante de sélection.
	 *  Pour être associée à ce composant, la liste des items doit se présenter de la façon suivante :
	 * 
	 *  <?xml version="1.0" encoding="UTF-8"?>
	 *  <root>
	 *		<item label="..." data="..."/>
	 *		<item label="..." data="..."/>
	 *		<item label="..." data="..."/>
	 *		...
	 *  </root>
	 * 
	 *  @remark Le nom de la balise racine (ici "root") n'a pas d'importante.
	 *  @remark Ce composant ne devrait pas être utilisé pour afficher une liste de sélection téléchargée depuis le WEB.
	 *          En effet, il existe un composant adapté à cette opération : HttpComboBox.
	 *  @remark Ce composant est susceptible de lancer les évènements suivants :
	 *          o DataSetted
	 *          o DataChanged
	 */

	public class ExtendedComboBox extends ComboBox implements IGhostInterface, IActorInterface, ICompositeActorInterface, ISelectorInterface
	{
		private var __myName:String;
		private var __onModifHd:Function = tools.FunctionUtilities.doNothing;
		
		public function ExtendedComboBox()
		{
			super();
			this.dataProvider = null;
			this.addEventListener(ListEvent.CHANGE, __dataChanged);
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque l'utilisateur modifie l'item sélectionné dans la liste de sélection déroulante.
		 *  @param even Cet évènement est envoyé lorsque l'utilisateur modifie l'item sélectionné dans la liste de sélection déroulante.
		 */
		
		private function __dataChanged(event:Event):void
		{
			__onModifHd(getSelectedValues());
			this.dispatchEvent(new Action('Action', __myName, 'DataChanged', true));
		}
		
		/** Cette méthode libère les ressources allouées au composant.
		 */
		
		public function destroy():void
		{
			this.removeEventListener(FlexEvent.DATA_CHANGE, __dataChanged);
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant.
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode permet de définir une fonction, qui sera exécutée par l'acteur, à chaque fois que ce dernier change d'état.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			if (inFunction != null) { __onModifHd = inFunction; }
		}
		
		/** Cette méthode renvoie les valeurs sélectionnées via le composant.
		 *  @return La méthode renvoie un objet qui présente les propriétés suivantes :
		 *          o data
		 *          o item
		 */
		
		public function getSelectedValues():Object
		{
			if (this.dataProvider == null) { throw new Error("Empty data provider!"); }

			return { data:this.selectedItem.@data, item:this.selectedItem };
		}
		
		/** Cette méthode permet d'initialiser le composant.
		 *  Cette initialisation concerne la liste d'item sélectionnable ou l'item sélectionné.
		 *  @param inValues Cet objet contient les valeurs utilisées pour réinitialiser le composant. Les propriétés de l'objet sont les suivantes :
		 *         o list: Si cette propriété est définie, alors sa valeur est utilisée pour définir la liste des items sélectionnables.
		 *         o itemData: Si cette propriété est définie, alors sa valeur est utilisée pour positionner l'item sélectionné, à partir de sa valeur.
		 *         o itemIndex: Si cette propriété est définie, alors sa valeur est utilisée pour positionner l'item sélectionné, à partir de son index.
		 *  @param inDispatchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à son initialisation.
		 *  @remark Le composant admet deux façons de désigner l'item sélectionné :
		 *          o En spécifiant sa valeur, définie par l'attribut "data".
		 *          o En spécifiant l'index de l'item dans la liste des items.
		 *          Si les deux façons de spécifier l'item courant sont spécifiées simultanément (par valeur ou par index), c'est la première (par valeur) qui est utilisée.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			if ((! inValues.hasOwnProperty('list')) && (this.dataProvider == null))
			{ throw new Error('The combo box must be associated to a data provider before any other action!'); }
			
			if (inValues.hasOwnProperty('list'))
			{
				this.dataProvider = new XMLListCollection(inValues.list.item);
				this.labelField   = '@label';
			}
			
			if (inValues.hasOwnProperty('itemData'))
			{
				this.selectedIndex = tools.DataProviderTools.getComboBoxDataProviderIndex('data', inValues.itemData, this.dataProvider);
			}
			else { if (inValues.hasOwnProperty('itemIndex')) { this.selectedIndex = inValues.itemIndex; } }
			
			if (inDispatchEvt) { this.dispatchEvent(new Action('Action', __myName, 'DataSetted', true)); }
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			this.enabled = true;
		}
		
		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			this.enabled = false;
		}
		
		/** Cette méthode permet de réinitialiser le composant.
		 *  Cette réinitialisation concerne la liste d'items sélectionnables, ou l'item sélectionné.
		 *  @param inValues Cet objet contient les valeurs utilisées pour réinitialiser le composant. Les propriétés de l'objet sont les suivantes :
		 *         o 'list': Si cette propriété est définie, alors sa valeur est utilisée pour définir la liste des items sélectionnables.
		 *         o 'itemData': Si cette propriété est définie, alors sa valeur est utilisée pour positionner l'item sélectionné, à partir de sa valeur.
		 *         o 'itemIndex': Si cette propriété est définie, alors sa valeur est utilisée pour positionner l'item sélectionné, à partir de son index.
		 *         Si cet argument vaut la valeur, alors la liste d'items sélectionnée est vidée.
		 */
		
		public function reset(inValues:Object=null):void
		{
			if (inValues == null) { this.dataProvider = null; return; }
			setValues(inValues, false);
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import values.Constants;
	

	import mx.controls.DateField;

	/** Cette classe assouplit l'utilisation de la classe standard "DateField".
	 *  Certaines propriétés du composant sont fixées en dure.
	 */

	public class ExtendedDateField extends DateField
	{
		private var __rangeStart:Date             = null;
		private var __rangeEnd:Date               = null;
		
		public function ExtendedDateField()
		{
			super();
			this.editable = false;
		}

		/** Cette méthode définit le début de la plage autorisée de sélection d'une date.
		 *  @param inDate Date de début de la plage de sélection.
		 *  @remark La classe standard définit un interval dans lequel la sélection est impossible.
		 *          La logique est inversée par rapport à la logique de la classe de base.
		 */
		
		public function enableRangeStart(inDate:Date):void
		{
			// trace ('enableRangeStart(' + inDate.toString() + ')');
			__rangeEnd = new Date(inDate.time - values.Constants.millisecondsPerDay);
			this.disabledRanges = [{rangeEnd: __rangeEnd}];
			if (__rangeStart != null) { this.disabledRanges.push({rangeStart: __rangeStart}); }
		}

		/** Cette méthode définit la fin de la plage autorisée de sélection d'une date.
		 *  @param inDate Date de fin de la plage de sélection.
		 *  @remark La classe standard définit un interval dans lequel la sélection est impossible.
		 *          La logique est inversée par rapport à la logique de la classe de base.
		 */	
		
		public function enableRangeEnd(inDate:Date):void
		{
			// trace ('enableRangeEnd(' + inDate.toString() + ')');
			__rangeStart = new Date(inDate.time + values.Constants.millisecondsPerDay);
			this.disabledRanges = [{rangeStart: __rangeStart}];
			if (__rangeEnd != null) { this.disabledRanges.push({rangeEnd: __rangeEnd}); }
		}
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.controls.TextArea;
	import mx.events.FlexEvent;
	
	import tools.FunctionUtilities;

	/**
	 * Cette classe permet de créer une zone d'édition simple, sur plusieurs ligne.
	 * Cette classe est susceptible de lancer deux types d'action :
	 *  o DataSetted
	 *  o TextChanged
	 */

	public class ExtendedTextArea extends TextArea implements IActorInterface, ICompositeActorInterface, IGhostInterface, ISelectorInterface
	{
		private var __onModifHd:Function = tools.FunctionUtilities.doNothing; 
		private var __myName:String;
		
		public function ExtendedTextArea()
		{
			super();
			this.addEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.addEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode permet de définir une fonction, qui sera exécutée par l'acteur, à chaque fois que ce dernier change d'état.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 *  @note Prototype de la fonction: inFunction(inData:Object=null):void
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			if (inFunction != null) { __onModifHd = inFunction }
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			this.removeEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.removeEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}
		
		/** Cette méthode retourne un objet qui contient le texte entré par l'utilisateur.
		 *  @return La méthode renvoie un objet qui présente la propriété "text". Cette propriété représente le texte entré par l'utilisateur.
		 */ 
		
		public function getSelectedValues():Object
		{
			return { text:this.text };
		}
		
		/** Cette méthode permet d'initialiser le composant avec un texte donné.
		 *  @param inValues Cet objet présente la propriété "text" qui représente le texte à injecter dans la zone d'édition.
		 *  @param inDispatchEvt Si ce paramètre vaut "true", alors un évènement est envoyé pour signaler que ma valeur a été initialisée.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			this.text = inValues.text;
			if (inDispatchEvt) { dispatchEvent(new Action('Action', __myName, "DataSetted", true)); }
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			this.enabled = true;
		}

		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			this.enabled = false;
		}
		
		/** Cette méthode permet de réinitialiser le contenu de la zone d'édition.
		 * 	En fonction de la valeur du paramètre "inValues", la zone est "vidée" ou elle se voit attribuer une valeur.
		 *  @param inValues Cet objet doit présenter la propriété "text" qui représente le texte à injecter dans la zone d'édition.
		 */
		
		public function reset(inValues:Object=null):void
		{
			if (inValues == null) { this.text = ''; return; }
			this.text = inValues.text;
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque le contenu de la zone d'édition change.
		 *  @param event Évènement envoyé lorsque le contenu de la zone d'édition change.
		 */
		
		private function __textChanged(event:Event):void
		{
			trace ('ExtendedTextArea + __textChanged()');
			__onModifHd(getSelectedValues());
			dispatchEvent(new Action('Action', __myName, "TextChanged", true));
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import components.popups.WaitBox;
	
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.net.FileReference;
	import flash.net.URLRequest;
	
	import gestionnaires.EventHandlerControler;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.containers.HBox;
	import mx.controls.Button;
	import mx.controls.Text;
	import mx.core.IFlexDisplayObject;
	import mx.events.FlexEvent;
	import mx.managers.PopUpManager;
	
	import tools.FunctionUtilities;

	/**
	 * Cette classe est destinée à faciliter le transfert de fichiers entre une application Flex et un serveur PHP.
	 */

	public class FileUploader extends HBox implements IGhostInterface, IActorInterface, ICompositeActorInterface, ISelectorInterface
	{
		private var __uploadUrl:String;
		private var __varName:String;
		private var __extensions:Array;
		private var __myName:String;
		private var __browseButtonLabel:String;
		private var __browseButton:Button;
		private var __pathScreen:Text;
		private var __browser:FileReference;
		private var __fileName:String;
		private var __popup:IFlexDisplayObject;
		private var __evtHd:EventHandlerControler = new EventHandlerControler();
		private var __onModifHd:Function = tools.FunctionUtilities.doNothing;

		
		/** Ce constructeur construit un composant de transfert de fichier.
		 *  @param inUploadUrl URL du scripte vers lequel le fichier doit être transféré.
		 *  @param inVarName Nom de la variable associée au fichier reçu par le serveur WEB.
		 *  @param inFileTypes Liste des extensions de fichiers supportées. Cette liste est composée d'éléments de type FileFilter.
		 *  @param inBrowseButtonLabel Texte à afficher sur le bouton qui va ouvrir la fenêtre d'exploration de l'arborescence.
		 */
		
		public function FileUploader(inUploadUrl:String, inVarName:String, inFileTypes:Array=null, inBrowseButtonLabel:String='Browse')
		{
			super();
			__uploadUrl = inUploadUrl;
			__varName = inVarName;
			__extensions = inFileTypes;
			__browseButtonLabel = inBrowseButtonLabel;
			__browser = new FileReference();
			__createInterface();
			__setEventHandler();
		}
		
		/** Cette méthode construit l'interface utilisateur.
		 */
		
		private function __createInterface():void
		{
			__browseButton = new Button();
			__browseButton.label = __browseButtonLabel;
			
			__pathScreen = new Text();
			__pathScreen.width = 200;
			__pathScreen.setStyle('fontWeight', 'bold');
			
			this.addChild(__pathScreen);
			this.addChild(__browseButton);
			 
		}
		
		/** Cette méthode est utilisée pour déclarer les évènements traités par cette classe.
		 */		
		
		private function __setEventHandler():void
		{
			__evtHd.addEventHandler(__browseButton, mx.events.FlexEvent.BUTTON_DOWN, __browse);
			__evtHd.addEventHandler(__browser, flash.events.Event.SELECT, __fileSelected);
			__evtHd.addEventHandler(__browser, flash.events.Event.COMPLETE, __uploadComplete);
			__evtHd.addEventHandler(__browser, flash.events.IOErrorEvent.IO_ERROR, __uploadFailed);
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			__evtHd.removeAllEventHandlers();
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode permet de définir une fonction, qui sera exécutée, qu'un nouveau fichier sera sélectionné.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 *  @note Prototype de la fonction: inFunction(inData:Object=null):void
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			__onModifHd = inFunction;
		}
		
		/** Cette méthode renvoie le nom du fichier sélectionnée par l'utilisateur.
		 *  @return Cette méthode renvoie un objet. Cet objet contient une clé "name", associé au nom du fichier.
		 */
		
		public function getSelectedValues():Object
		{
			return { name: __fileName };
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			__browseButton.enabled = true;	
		}
		
		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			__browseButton.enabled = false;
		}

		// ---------------------------------------------------------------------------------
		// Gestionnaires d'évènements.
		// ---------------------------------------------------------------------------------

		/** Ce gestionnaire d'évènement est exécuté lorsque l'utilisateur presse le bouton de sélection du fichier à transférer.
		 *  @param event Évènement envoyé lorsque le bouton de sélection du fichier est pressé.
		 */
		
		private function __browse(event:Event):void
		{
			__browser.browse(__extensions);
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque l'utilisateur sélectionne un fichier.
		 *  @param event Évènement envoyé lorsque l'utilisateur sélectionne un fichier.
		 */
		
		private function __fileSelected(event:Event):void
		{
			var url:URLRequest;
			
			__fileName = __browser.name;
			if (__fileName == null) { return; }
			__pathScreen.text = __fileName;
			
			// On exécute la fonction qui doit être exécutée à chaque modification du nom du fichier sélectionné.
			__onModifHd(getSelectedValues());
			
			// On active la boîte modale qui représente l'attente.
			url = new URLRequest(__uploadUrl);
			__popup = PopUpManager.createPopUp(this.parent, components.popups.WaitBox, true);
			PopUpManager.centerPopUp(__popup);
			__browser.upload(url, __varName);
		}

		/** Ce gestionnaire d'évènement est exécuté lorsque le fichier est totalement transféré sur le serveur.
		 *  @param event Cet évènement est envoyé lorsque le fichier est totalement transféré sur le serveur.
		 */

		private function __uploadComplete(event:Event):void
		{
			PopUpManager.removePopUp(__popup);
		}
		
		/** Cegestionnaire d'évènement est exécuté si une erreur se produit lors du transfert du fichier vers le serveur.
		 *  @param Cet évènement est envoyé si une erreur se produit lors du transfert du fichier vers le serveur. 
		 */
		
		private function __uploadFailed(event:Event):void
		{
			var popup:IFlexDisplayObject;
			
			PopUpManager.removePopUp(__popup);
			popup = PopUpManager.createPopUp(this.parent, components.popups.ServerError, true);
			PopUpManager.centerPopUp(popup);
		}

		// ---------------------------------------------------------------------------------
		// Fonctions non implémentées.
		// ---------------------------------------------------------------------------------
		
		/** Dans le cas particulier de ce composant, cette fonction n'est pas utilisable.
		 *  @param inValues NA.
		 *  @note Cette méthode est définie uniquement pour implémenter l'interface ISelectorInterface.
		 */
		
		public function reset(inValues:Object=null):void { }

		/** Dans le cas particulier de ce composant, cette fonction n'est pas utilisable.
		 *  @param inValues NA.
		 *  @param inDisparchEvt NA.
		 *  @note Cette méthode est définie uniquement pour implémenter l'interface ISelectorInterface.
		 */

		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void { }
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import mx.containers.Box;
	import mx.containers.VBox;
	import mx.controls.Label;
	import mx.controls.Spacer;

	public class TitleLabel extends VBox
	{
		private var __css:Object   = null;
		private var __title:Label  = null;
		private var __titleBox:Box = null;
		
		/**
		 * Cette classe définit un titre de section pour des formulaires.
		 * @param inText Titre de la section.
		 * @param inUpHeight Distance entre le titre et "le plafond".
		 * @param inDownHeight Distance entre le titre et "le plancher".
		 * @param inCss Cet objet contient les noms des classes CSS à appliquer.
	 	 *        Les propriétés sont les suivantes :
	 	 *        o 'titleText': Apparence du titre.
	 	 *        o 'titleContainer': Apparence du conteneur.
		 */
		
		public function TitleLabel(inText:String, inUpHeight:int, inDownHeight:int, inCss:Object=null)
		{
			
			var upSpacer:Spacer   = new Spacer();
			var downSpacer:Spacer = new Spacer();
			
			super();
			
			__title    = new Label();
			__titleBox = new Box();
			
			__title.percentWidth    = 100;
			__titleBox.percentWidth = 100;
			this.percentWidth       = 100;
			upSpacer.percentWidth   = 100;
			downSpacer.percentWidth = 100;
			
			upSpacer.height   = inUpHeight;
			downSpacer.height = inDownHeight;
			__title.text      = inText;
			__css = inCss;
			__setCss();
			
			__titleBox.addChild(__title);
			this.addChild(upSpacer);
			this.addChild(__titleBox);
			this.addChild(downSpacer);
		}
		
		/**
		 * Cette méthode applique les CSS au composant.
		 */
		
		private function __setCss():void
		{
			if (__css != null)
			{
				if (__css.hasOwnProperty('titleText'))      { __title.styleName    = __css.titleText; }
				if (__css.hasOwnProperty('titleContainer')) { __titleBox.styleName = __css.titleContainer; }
			}
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import interfaces.ISelectorInterface;
	
	import mx.controls.DataGrid;

	public class ExtendedDataGrid extends DataGrid implements ISelectorInterface
	{
		public function ExtendedDataGrid()
		{
			super();
		}
		
		/** Cette méthode renvoie les valeurs sélectionnées par l'utilisateur.
		 *  Dans le cas d'un composant de ce type, l'objet sélectionné est la ligne de la matrice.
		 */
		
		public function getSelectedValues():Object
		{
			return null;
		}
		
		/** Cette méthode permet d'initialiser un composant de sélection avec des valeurs.
		 *  @param inValues Cet objet contient les valeurs utilisées pour l'initialisation du composant.
		 *  @param inDisparchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à la mise à jour de l'heure.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			
		}

		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			
		}

		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         Chaque propriété de l'objet représente une propriété à réinitialiser.
		 */
		
		public function reset(inValues:Object=null):void
		{
			
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.controls.RichTextEditor;
	import mx.events.FlexEvent;
	
	import tools.FunctionUtilities;
	
	/** Cette classe étend le composant d'édition élaboré de Flex.
	 *  Ce composant est susceptible d'envoyer des actions de types :
	 *  o DataSetted
	 *  o TextChanged
	 */

	public class ExtendedRichTextEditor extends RichTextEditor implements IActorInterface, ICompositeActorInterface, IGhostInterface, ISelectorInterface
	{
		private var __onModifHd:Function = tools.FunctionUtilities.doNothing;
		private var __myName:String;
		
		/** Cette méthode construit une instance d'éditeur.
		 */
		
		public function ExtendedRichTextEditor()
		{
			this.addEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.addEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}

		/** Ce gestionnaire d'évènement est exécuté lorsque le contenu de l'éditeur change.
		 *  @param event Évènement qui signale un changement de contenu de l'éditeur.
		 */

		private function __textChanged(event:Event):void
		{
			__onModifHd(getSelectedValues());
			dispatchEvent(new Action('Action', __myName, "TextChanged", true));
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */

		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode permet de déclarer une fonction qui sera automatiquement exécutée à chaque modification du contenu de l'éditeur.
		 *  @param inFunction Fonction à exécuter.
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			if (inFunction != null) { __onModifHd = inFunction }
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			this.removeEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.removeEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}
		
		/** Cette méthode renvoie le texte entré par l'utilisateur.
		 *  @return La méthode renvoie un objet qui présente deux propriétés :
		 *          o 'text': Le contenu de l'éditeur, sans aucun formatage.
		 *          o 'html': Le contenu de l'éditeur, avec un formatage HTML.
		 */
		
		public function getSelectedValues():Object
		{
			return { text:this.text, html:this.htmlText };
		}
		
		/** Cette méthode permet de remplir la zone d'édition avec du texte.
		 *  @param inValues Cet objet contient le texte à injecter dans l'éditeur.
		 *         Deux formats de texte sont pris en charge :
		 *         o 'text': Texte brut.
		 *         o 'html': HTML.
		 *         Seul un type de format est accepté. Si les deux sont présents, alors le format HTML sera utilisé.
		 *  @param inDispatchEvt Cet indicateur permet de spécifier si l'on désire envoyer un évènement ou non lors de l'initialisation du composant.
		 *         La valeur va entraîner l'envoi d'un évènement de type "DataSetted".
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			if (inValues.hasOwnProperty('html')) { this.htmlText = inValues.html; }
			else { if (inValues.hasOwnProperty('text')) { this.text = inValues.text; } }
			
			if (inDispatchEvt) { dispatchEvent(new Action('Action', __myName, "DataSetted", true)); }
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			this.enabled = true;	
		}
		
		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			this.enabled = false;
		}
		
		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         Chaque propriété de l'objet représente une propriété à réinitialiser.
		 */
		
		public function reset(inValues:Object=null):void
		{
			this.text = '';
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.controls.TextInput;
	import mx.events.FlexEvent;
	
	import tools.FunctionUtilities;

	/**
	 * Cette classe permet de créer une zone d'édition simple, sur une seule ligne.
	 * Cette classe est susceptible de lancer deux types d'action :
	 *  o DataSetted
	 *  o TextChanged
	 */

	public class ExtendedTextInput extends TextInput implements IActorInterface, ICompositeActorInterface, IGhostInterface, ISelectorInterface
	{
		private var __onModifHd:Function = tools.FunctionUtilities.doNothing; 
		private var __myName:String;
		
		public function ExtendedTextInput()
		{
			super();
			this.addEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.addEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode permet de définir une fonction, qui sera exécutée par l'acteur, à chaque fois que ce dernier change d'état.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 *  @note Prototype de la fonction: inFunction(inData:Object=null):void
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			if (inFunction != null) { __onModifHd = inFunction }
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			this.removeEventListener(flash.events.Event.CHANGE,        __textChanged);
			this.removeEventListener(mx.events.FlexEvent.VALUE_COMMIT, __textChanged);
		}
		
		/** Cette méthode retourne un objet qui contient le texte entré par l'utilisateur.
		 *  @return La méthode renvoie un objet qui présente la propriété "text". Cette propriété représente le texte entré par l'utilisateur.
		 */ 
		
		public function getSelectedValues():Object
		{
			return { text:this.text };
		}
		
		/** Cette méthode permet d'initialiser le composant avec un texte donné.
		 *  @param inValues Cet objet présente la propriété "text" qui représente le texte à injecter dans la zone d'édition.
		 *  @param inDispatchEvt Si ce paramètre vaut "true", alors un évènement est envoyé pour signaler que la valeur a été initialisée.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			this.text = inValues.text;
			if (inDispatchEvt) { dispatchEvent(new Action('Action', __myName, "DataSetted", true)); }
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			this.enabled = true;
		}

		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			this.enabled = false;
		}
		
		/** Cette méthode permet de réinitialiser le contenu de la zone d'édition.
		 * 	En fonction de la valeur du paramètre "inValues", la zone est "vidée" ou elle se voit attribuer une valeur.
		 *  @param inValues Cet objet doit présenter la propriété "text" qui représente le texte à injecter dans la zone d'édition.
		 */
		
		public function reset(inValues:Object=null):void
		{
			if (inValues == null) { this.text = ''; return; }
			this.text = inValues.text;
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque le contenu de la zone d'édition change.
		 *  @param event Évènement envoyé lorsque le contenu de la zone d'édition change.
		 */
		
		private function __textChanged(event:Event):void
		{
			__onModifHd(getSelectedValues());
			dispatchEvent(new Action('Action', __myName, "TextChanged", true));
		}
		
	}
}

/* Author: Denis BEURIVE */

package components.baseComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import gestionnaires.EventHandlerControler;
	
	import interfaces.IActorInterface;
	import interfaces.ICompositeActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.collections.XMLListCollection;
	import mx.controls.ComboBox;
	import mx.events.FlexEvent;
	import mx.events.ListEvent;
	
	import tools.DataProviderTools;
	import tools.FunctionUtilities;
	import tools.HttpLoader;

	/** Cette classe implémente une boîte de sélection dont les paramètres nécessaires à son initialisation sont récupérés via HTTP.
	 *  Pour être associé à une composant de type "ComboBox", le document téléchargé doit présenter la structure suivante :
	 * 
	 *  <?xml version="1.0" encoding="UTF-8"?>
	 *  <root>
	 *		<item label="..." data="..."/>
	 *		<item label="..." data="..."/>
	 *		<item label="..." data="..."/>
	 *		...
	 *  </root>
	 * 
	 *  Ce composant est susceptible de diffuser les évènements suivants :
	 *  o DataSelected - Cela signifie que le contenu du composant de sélection a été modifié (peu importe la nouvelle valeur sélectionnée).
	 *  o DataSetted - Cet évènement signifie que l'action d'initialisation de la valeur sélectionnée a été effectuée.	
	 * 
	 *  @remark Le nom de la balise racine (ici "root") n'a pas d'importante.
	 *  @remark Le nom de la balise qui définit les entrées (ici "item") est configurable (CF méthode setValues()).
	 *  @remark Le nom de la propriété qui définit le texte affiché sur chaque ligne de la boîte de sélection (ici "label") est configurable (CF méthode setValues()).
	 *  @remark Le nom de la propriété qui définit la valeur sélectionnée (ici "data") n'a pas d'importance (CF méthode setValues()).
	 *  @remark Si le document d'origine ne se présente cette structure, ce n'est pas un problème.
	 *          L'utilisateur de cette classe est invité à déclarer un greffon destiné à convertir le document téléchargé avant son utilisation.
	 *  @remark L'utilisateur peut également définir un greffon qui sera exécuté après l'injection des données téléchargées dans le composant de sélection.
	 * 
	 *  @warning Le chargement des informations d'initialisation du composant ne peut être effectué que lorsque l'application est entièrement initialisée!
	 *           Cette contrainte est justifiée par le fait que le composant lance un popup.
	 */

	public class HttpComboBox extends ComboBox implements IActorInterface, IGhostInterface, ISelectorInterface, ICompositeActorInterface
	{
		private var __evtHd:EventHandlerControler = new EventHandlerControler();
		private var __userPrePlugin:Function      = null;
		private var __userPostPlugin:Function     = null;
		private var __selectedData:String         = null;
		private var __onModifHd:Function          = tools.FunctionUtilities.doNothing;
		private var __values:Object;
		private var __myName:String;
		private var __http:HttpLoader;
		
		/** Crée une boîte de sélection dont les paramètres d'initialisation sont récupérés via HTTP.
		 *  @param inURL URL vers les paramètres d'initialisation de la boîte de sélection.
		 */
		
		public function HttpComboBox()
		{
			super();
			__http = new HttpLoader(this);
			__setEventHandler();
		}
		
		/** Cette méthode charge les données qui permettront d'initialiser le composant.
		 *  @param inValues Cet objet contient les valeurs utilisées pour initialiser le composant.
		 *         Ces valeurs sont:
		 *         o url: URl vers le document (ou le service WEB).
		 *         o plugin: Référence vers une fonction dont le rôle est de convertir le document téléchargé en un format compatible avec l'utilisation du composant "ComboBox".
		 *                   Cette fonction va également effectuer des opérations sur la boîte de sélection, une fois cette dernière initialisée.
		 *         o format: Ce paramètre indique le format vers lequel le document téléchargé doit être converti (CF doc FLEX HTTPService.resultFormat).
		 *         o method: "GET" ou "POST".
		 *         o values: Objet qui contient les valeurs à envoyer au service WEB (si l'URL pointe vers un service WEB).
		 *                   Si aucune valeur ne doit être envoyée, cette valeur doit être null.
		 *         o item: Nom de la balise qui contient les valeurs stockées dans le composant.
		 *         o label: Nom de l'attribut qui représente le texte associé à la valeur.
		 *         o data: Nom de l'attribut qui représente la valeur de l'élément sélectionné.
		 * 
		 *  @remark: Pour être associé à une composant de type "ComboBox", le document téléchargé doit présenter la structure suivante :
	 	 * 
		 *  <?xml version="1.0" encoding="UTF-8"?>
		 *  <root>
		 *		<item label="..." data="..."/>
		 *		<item label="..." data="..."/>
		 *		<item label="..." data="..."/>
		 *		...
		 *  </root>
		 */
		
		private function __loadData(inValues:Object):void
		{
			__http.load(inValues.url, inValues.plugin, inValues.format, true, inValues.values, inValues.method);
			// trace ("HttpCombo: Data loadded");
			// trace ("HttpCombo: " + __http.error());
		}
		
		/** Cette méthode est utilisée pour déclarer les évènements traités par cette classe.
		 */		
		
		private function __setEventHandler():void
		{
			__evtHd.addEventHandler(this, ListEvent.CHANGE,                 __comboClosed);
			__evtHd.addEventHandler(this, mx.events.FlexEvent.VALUE_COMMIT, __comboClosed);
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque la boîte de sélection est refermée.
		 *  @param event Évènement envoyé lorsque la boîte de sélection se referme.
		 */
		
		private function __comboClosed(event:Event):void
		{
			var selectedData:String;
			
			// Il est important de ne pas exécuter cette action avant que le composant ne soit complètement initialisé.
			// Avant que le composant ne soit complètement initialisé, l'appel à la méthode "setName()" ne peut pas avoir été effectué.
			// Le troisième paramètre du constructeur de l'évènement doit valoir "true".
			
			if (initialized)
			{
				if (__myName === null) { throw new Error('The component has no name.'); }
				dispatchEvent(new Action('Action', __myName, "DataSelected", true));
				__onModifHd(getSelectedValues());
			}
			// trace ('__comboClosed()');
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			__evtHd.removeAllEventHandlers();
			__http.destroy();
		}
		
		/** Cette méthode renvoie les valeurs sélectionnées par l'utilisateur.
		 *  @return La méthode renvoie un objet qui contient les valeurs sélectionnées.
		 *          La valeur sélectionnée est représentée par la propriété "value" de l'objet retourné.
		 *          La valeur retournée peut être égale à null si aucun item n'a été sélectionné.
		 */
		
		public function getSelectedValues():Object
		{
			var item:XML;
			
			if (this.selectedItem == null) { return { value:null }; }
			
			item = XML(this.selectedItem);
			// trace(item.attribute(__values.data));
			return { value:item.attribute(__values.data).toString() };
		}
		
		/** Cette méthode permet d'initialiser un composant de sélection avec des valeurs.
		 *  @param inValues Cet objet contient les valeurs utilisées pour initialiser le composant.
		 *         o url: URl vers le document (ou le service WEB).
		 *         o prePlugin: Référence vers une fonction dont le rôle est de convertir le document téléchargé en un format compatible avec l'utilisation du composant "ComboBox".
		 *		   o postPlugin: Référence vers une fonction qui sera exécutée lorsque le document aura été totalement téléchargé. 
		 *         o format: Ce paramètre indique le format vers lequel le document téléchargé doit être converti (CF doc FLEX HTTPService.resultFormat).
		 *         o method: "GET" ou "POST".
		 *         o values: Objet qui contient les valeurs à envoyer au service WEB (si l'URL pointe vers un service WEB).
		 *           Si aucune valeur ne doit être envoyée, cette valeur doit être null.
		 *         o item: Nom de la balise qui contient les valeurs stockées dans le composant.
		 *         o label: Nom de l'attribut qui représente le texte associé à la valeur.
		 *         o data: Nom de l'attribut qui représente la valeur de l'élément sélectionné.
		 *         o selectedData: Si elle est définie, cette valeur représente la valeur présélectionnée de la liste de sélection.
		 *  @param inDisparchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à la mise à jour de l'heure.
		 * 
		 *  @warning ATTENTION!!! Cette méthode déclenche l'apparition d'une fenêtre surgissante.
		 *           La fenêtre surgissante requiert une fenêtre parente. On ne peut donc pas exécuter cette fonction tant que l'application n'est pas complètement initialisée!
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			// Chargement des valeurs d'initialisation.
			// Attention : Le chargement des documents est une opération asynchrone!
			// L'exécution de la fonction se poursuit alors que le document n'a pas encore été téléchargé!
			// C'est la raison pour laquelle nous passons un greffon (__httpPlugin) qui sera exécuté lorsque le document aura été téléchargé.
			// Ce greffon (__httpPlugin) va appeler les fonctions définies par l'utilisateur.

			__values          = inValues;
			__values.dispatch = inDispatchEvt;
			__userPrePlugin   = inValues.prePlugin;
			__userPostPlugin  = inValues.postPlugin;
			inValues.plugin   = __httpPlugin;
			__loadData(inValues);
		}
		
		/** Cette méthode constitue un greffon qui est passé à l'objet chargé de télécharger les données d'initialisation vie HTTP.
		 *  Si (et seulement si) les données d'initialisation sont correctement téléchargées, alors ce greffon est exécuté.
		 *  Ce greffon met à jour la boîte de sélection.
		 *  @param inValue Ce paramètre contiendra le document téléchargé par le composant de téléchargement.
		 *  @return La fonction renvoie la transformation du document téléchargé.
		 * 
		 *  @remark Il serait également possible de renvoyer la valeur null.
		 *  @remark Par l'intermédiaire des greffons passés en paramètres de la fonction "setValues()", ce code lance l'exécution du code spécifique, fournit par l'utilisateur.
		 */
		 
		private function __httpPlugin(inValue:Object):Object
		{
			var doc:Object;
			
			// Conversion du document téléchargé.
			doc = __userPrePlugin(inValue); 
			
			// Mise à jour du composant de sélection.
			this.dataProvider = new XMLListCollection(doc.elements(__values.item));
			this.labelField   = '@' + String(__values.label);
			
			// Association éventuelle de la valeur de présélection.
			if (__values.hasOwnProperty('selectedData')) { this.selectedIndex = tools.DataProviderTools.getComboBoxDataProviderIndex(__values.data, __values.selectedData, this.dataProvider); } 

			// Exécution du code spécifique fournit par l'utilisateur.
			if (__userPostPlugin != null) { __userPostPlugin(doc); }
			
			// Lance un éventuel évènement pour signaler que l'assignation de valeur a été effectuée.
			if (__values.dispatch) { dispatchEvent(new Action('Action', __myName, "DataSetted", true)); }
			
			return doc;		
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void { this.enabled = true; }

		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void { this.enabled = false; }
		
		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         Chaque propriété de l'objet représente une propriété à réinitialiser.
		 */
		
		public function reset(inValues:Object=null):void
		{
			this.dataProvider = null;
		}
		
		/** Cette méthode permet de définir une fonction, qui sera exécutée par l'acteur, à chaque fois que ce dernier change d'état.
		 *  @param inFunction Fonction exécutée par le composant à chaque fois que ce dernier change d'état.
		 */
		
		public function setOnModificationHandler(inFunction:Function=null):void
		{
			if (inFunction == null) { return; }
 			__onModifHd = inFunction;
		}
		
	}
}

Quelques composants spéciaux

/* Author: Denis BEURIVE */

package components.UIComponents
{
	import components.baseComponents.ExtendedDateField;
	
	import evenements.Action;
	
	import flash.events.Event;
	
	import gestionnaires.EventHandlerControler;
	
	import interfaces.IActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.containers.HBox;
	import mx.controls.Spacer;
	import mx.events.CalendarLayoutChangeEvent;

	/** Cette classe implémente un composant utilisé pour sélectionner une date et une heure.
	 *  Ce composant peut diffuser les actions suivantes :
	 *  o TimeChanged
	 *  o DateChanged
	 * 
	 *  Note: Les actions de type "TimeChanged" sont envoyées par les "sous composants" de type "TimePicker".
	 */

	public class DateTimePicker extends HBox implements IGhostInterface, ISelectorInterface, IActorInterface
	{
		private var __datePicker:ExtendedDateField;
		private var __timePicker:TimePicker;
		private var __enabled:Boolean              = new Boolean();
		private var __evtHd:EventHandlerControler  = new EventHandlerControler();
		private var __myName:String                = null;
		private var __css:Object                   = null;
		
		/** Construit un objet de sélection de la date et de l'heure.
		 *  @param enabled Cette valeur détermine l'état initial du composant.
		 *         Les valeurs possibles sont :
		 *         * true 
		 *         * false
		 *         Par défaut, le composant est actif.
		 *  @param fromDate Objet de type "Date". Cet objet représente la date de "début" du calendrier (exclue). La sélection est impossible avant cette date (y compris!).
		 *         Par défaut, cette date n'est pas définie.
		 *  @param toDate Objet de type "Date". Cet objet représente la date de "fin" du calendrier. La sélection est impossible après cette date (y compris!).
		 *         Par défaut, cette date n'est pas définie.
		 *  @param time L'heure d'initialisation. Deux formats sont utilisables :
		 *              - Un nombre entier compris entre 0 et 1439 (inclus), qui représente le nombre de minutes écoulées depuis 0h.
		 *              - Une chaîne "HH:MM".  
		 *  @param timeStep Taille de la marche entre deux variations du sélecteur d'heure.
		 *  @param language Cette chaîne de caractères définit la langue utilisée pour l'affichage de la date.
		 *         Les valeurs possibles sont :
		 *         * french
		 *         * english
		 *         La langue utilisée par défaut est l'anglais.
		 *  @param inCSS Cet objet contient les noms des classes CSS à appliquer.
		 *         Les propriétés sont les suivantes :
	 	 *         o 'clockText':            Nom de la classe CSS qui détermine l'apparence du texte de l'horloge.
	 	 *         o 'clockButton':          Nom de la classe CSS qui détermine l'apparence des boutons de l'horloge.
	 	 *         o 'clockBox':             Nom de la classe CSS qui détermine l'apparence du conteneur de l'horloge.
	 	 *         o 'dateClockContainer':   Nom de la classe CSS qui détermine l'apparence du conteneur.
		 *         o 'dateClockCalendar':    Nom de la classe CSS qui détermine l'apparence du calendrier.
		 */
		
		public function DateTimePicker(enabled:Boolean=true,
		                               fromDate:Date=null,
		                               toDate:Date=null,
		                               time:String="0",
		                               timeStep:Number=1,
		                               language:String='english',
		                               inCss:Object=null)
		{
			super();
			__enabled  = enabled;
			__css      = inCss; trace("DateTimePicker\n" + __css.toString());  
			
			
			
			// Création des composants.
			__datePicker = new ExtendedDateField();
			__timePicker = new TimePicker(10, "0", __css);
			
			// Initialisation de l'heure du composant.
			__timePicker.setValues({time:time, step:timeStep});
			
			// Configuration du calendrier.
			__datePicker.yearNavigationEnabled = false;
			__datePicker.showToday             = true;
			if (language == 'french')
			{
				__datePicker.dayNames   = new Array('D', 'L', 'M', 'M', 'J', 'V', 'S');
				__datePicker.monthNames = new Array('Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre');
			}
			if ((fromDate != null) || (toDate   != null)) { __datePicker.disabledRanges = []; }
			if (fromDate != null)     { __datePicker.disabledRanges.push({rangeEnd: fromDate}); }
			if (toDate   != null)     { __datePicker.disabledRanges.push({rangeStart: toDate}); }
			if (! __enabled) { disable(); }
			
			__createTimeChooser();
			__setEventHandler();
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;		
			__timePicker.setName(inName);
		}
		
		/** Cette méthode est utilisée pour déclarer les évènements traités par cette classe.
		 */		
		
		private function __setEventHandler():void
		{
			__evtHd.addEventHandler(__datePicker, CalendarLayoutChangeEvent.CHANGE, __dateUpdated);
		}
		
		/** Crée le composant utilisé pour sélectionner une heure.
		 */
		
		private function __createTimeChooser():void
		{
			var dateHourSpacer:Spacer = new Spacer();
			
			// Séparateur entre de composant de sélection de la date et celui de l'heure.
			dateHourSpacer.width         = 5;
			dateHourSpacer.percentHeight = 100;
			
			// Le sélecteur de l'heure est désactivé à la création du composant.
			// On suppose que l'heure n'est ajustable que si l'on a, au préalable, choisi une date.
			__timePicker.disable();
			
			// Application des CSS.
			__setCss();
			
			// Assemblage			
			this.horizontalScrollPolicy = "off";
			this.verticalScrollPolicy   = "off";
			this.setStyle("verticalAlign", "middle");
			this.addChild(__datePicker);
			this.addChild(dateHourSpacer);
			this.addChild(__timePicker);
		}
		
		/**
		 * Cette méthode applique les CSS au composant.
		 */
		
		private function __setCss():void
		{
			if (__css != null)
			{
				if (__css.hasOwnProperty('dateClockContainer')) { this.styleName         = __css.dateClockContainer; }
				if (__css.hasOwnProperty('dateClockCalendar'))  { __datePicker.styleName = __css.dateClockCalendar; }
				
				
			}
		}
		
		/** Cette méthode rend le composant éligible à la destruction.
		 */
		
		public function destroy():void
		{
			__evtHd.removeAllEventHandlers();
			__timePicker.destroy();
		}
		
		/** Cette méthode renvoie la date sélectionnée.
		 *  La date retournée ne comporte pas d'information sur l'heure (HH=00, MM=00, SS=00).
		 *  @return Cette méthode renvoie la date sélectionnée.
		 *          If no date has been selected, the function returns the value null.
		 */
		
		public function selectedDate():Date { return __datePicker.selectedDate; }

		/** Cette méthode renvoie la date et l'heure sélectionnée.
		 *  @return Cette méthode renvoie la date et l'heure sélectionnée.
		 *          If no date has been selected, the function returns the value null.
		 */
		
		public function selectedDateTime():Date
		{
			var o:Object;

			if (__datePicker.selectedDate == null) { return null; }
			o = getSelectedValues();
			trace ('selectedDateTime() : year:' + o.year + ' month:' + o.month + ' day:' + o.date + ' hour:' + o.hour + ' minute:' + o.minute);   
			return new Date(o.year, o.month, o.date, o.hour, o.minute, 0, 0);
		}
		
		/** Cette méthode renvoie les valeurs sélectionnées par l'utilisateur.
		 *  @return La méthode renvoie un objet qui contient deux propriétés :
		 *          * hour    // L'heure.
		 *          * minute  // Le nombre de minutes depuis le début de l'heure.
		 *          * value   // Le nombre total de minutes depuis 0h.
		 *          * date    // 1 à 31
		 *          * day     // 0 pour Sunday, 1 pour Monday
		 *          * year    // The year
		 *          * month   // 0 pour January, 1 pour February
		 *          If no date has been selected, the function returns the value null.
		 */
		
		public function getSelectedValues():Object
		{
			var values:Object;
			
			if (__datePicker.selectedDate == null) { return null; }
			values = __timePicker.getSelectedValues();
			values.date  = __datePicker.selectedDate.date;
			values.day   = __datePicker.selectedDate.day;
			values.year  = __datePicker.selectedDate.fullYear;
			values.month = __datePicker.selectedDate.month;
			return values;
		}
		
		/** Cette fonction renvoie uniquement l'heure sélectionnée, sous la forme d'une chaîne de caractères ("HH:MM").
		 *  @return La fonction renvoie uniquement l'heure sélectionnée, sous la forme d'une chaîne de caractères ("HH:MM").
		 *          If no date has been selected, the function returns the value null.
		 */
		
		public function getTimeAsString():String
		{
			if (__datePicker.selectedDate == null) { return null; }
			return __timePicker.getSelectedValues().hour + ':' + __timePicker.getSelectedValues().minute; 
		}
		
		/** Cette méthode permet d'initialiser un composant de sélection avec des valeurs.
		 *  @param inValues Cet objet contient les valeurs utilisées pour l'initialisation du composant.
		 *         L'objet passé en argument de la méthode peut contenir les propriétés suivantes :
		 *         * time: Valeur utilisée pour initialiser l'horloge. Deux formats sont utilisables :
		 *                 - Un nombre entier compris entre 0 et 1439 (inclus), qui représente le nombre de minutes écoulées depuis 0h.
		 *                 - Une chaîne "HH:MM". 
		 *         * step: Valeur de la marche entre deux valeurs successives des minutes.
		 *         * date: Objet de type Date.
		 *         * bagin: Date de bébut de l'interval de sélection.
		 *         * end: Date de fin de l'interval de sélection.
		 *  @param inDispatchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à la mise à jour de l'heure.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			__timePicker.setValues(inValues, inDispatchEvt);
			if (inValues.hasOwnProperty('date'))  { __datePicker.selectedDate = inValues.date; }
			if (inValues.hasOwnProperty('begin')) { __datePicker.enableRangeStart(inValues.begin); }
			if (inValues.hasOwnProperty('end'))   { __datePicker.enableRangeEnd(inValues.end); }
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			__datePicker.enabled = true;
			__timePicker.enable();
		}
		
		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			__datePicker.enabled = false;
			__timePicker.disable();
		}

		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         Chaque propriété de l'objet représente une propriété à réinitialiser.
		 *         Les propriétés possibles sont :
		 *         o time
		 *         * step
		 *         o date
		 */
		
		public function reset(inValues:Object=null):void
		{
			if (inValues == null)
			{
				__datePicker.selectedDate = null;
				__timePicker.reset();
				__disableTimePicket();
				return;
			}
			
			if (inValues.hasOwnProperty('time'))	{
														__timePicker.reset(inValues);
														// trace ('DateTimePicker(' + __myName  + '): time cleared.');
													}
			if (inValues.hasOwnProperty('date'))	{
														__datePicker.selectedDate = null;
														__disableTimePicket();
														// trace ('DateTimePicker(' + __myName  + '): Text cleared.');
													}
		}
		
		/** Cette méthode désactive le sélecteur de l'heure.
		 */
		
		private function __disableTimePicket():void
		{
			__timePicker.setTime('00:00');
			__timePicker.disable();
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque la date sélectionnée sur le calendrier est modifiée.
		 *  @param event Evènement reçut.
		 */
		
		private function __dateUpdated(event:Event):void
		{
			// Il est important de ne pas exécuter cette action avant que le composant ne soit complètement initialisé.
			// Avant que le composant ne soit complètement initialisé, l'appel à la méthode "setName()" ne peut pas avoir été effectué.
			// Le troisième paramètre du constructeur de l'évènement doit valoir "true".
			
			if (initialized)
			{
				if (__myName === null) { throw new Error('The component has no name.'); }
				dispatchEvent(new Action('Action', __myName, "DateChanged", true));
				trace ('DateTimePicker(' + __myName + '): DateChanged');
				__timePicker.enable();
			}
		}
	}
}

/* Author: Denis BEURIVE */

package components.UIComponents
{
	import evenements.Action;
	
	import flash.events.Event;
	
	import gestionnaires.EventHandlerControler;
	
	import interfaces.IActorInterface;
	import interfaces.IGhostInterface;
	import interfaces.ISelectorInterface;
	
	import mx.containers.HBox;
	import mx.containers.VBox;
	import mx.controls.Button;
	import mx.controls.Spacer;
	import mx.controls.Text;
	import mx.events.FlexEvent;

	/** Cette classe implémente un composant qui permet de sélectionner une heure à la façon d'un "NumericStepper".
	 *  Ce composant peut diffuser les actions suivantes :
	 *  o TimeChanged
	 */

	public class TimePicker extends HBox implements IGhostInterface, ISelectorInterface, IActorInterface
	{
		private var __clockScreen:Text            = new Text();
		private var __upButton:Button             = new Button();
		private var __downButton:Button           = new Button();
		private var __evtHd:EventHandlerControler = new EventHandlerControler();
		private var __myName:String;
		private var __currentStep:Number = 0;    // Numéro de la marche courante. Ce nombre croit, ou décroît, par unité de 1.
		private var __stepSize:Number    = 1;    // Taille de la marche.
		private var __upperStep:Number   = 0;    // Numéro de la marche la plus haute (limite supérieure de __currentStep).
		private var __css:Object         = null;
		
		/** construit un objet de type "TimePicker".
		 *  @param inStepSize Valeur de la marche entre deux valeurs successives des minutes.
		 *  @param inTime Valeur utilisée pour initialiser l'horloge. Deux formats sont utilisables :
		 *         o Un nombre entier compris entre 0 et 1439 (inclus), qui représente le nombre de minutes écoulées depuis 0h.
		 *         o Une chaîne "HH:MM".
		 *  @param inCSS Cet objet contient les noms des classes CSS à appliquer.
	 	 *         Les propriétés sont les suivantes :
	 	 *         o 'clockText':   Nom de la classe CSS qui détermine l'apparence du texte de l'horloge.
	 	 *         o 'clockButton': Nom de la classe CSS qui détermine l'apparence des boutons de l'horloge.
	 	 *         o 'clockBox':    Nom de la classe CSS qui détermine l'apparence du conteneur.
  		 */
		
		public function TimePicker(inStepSize:Number=1,
		                           inTime:String="0",
		                           inCss:Object=null)
		{
			super();
			__css = inCss; trace ("TimePicker\n" + __css.clockText);
			__createTimePicker();
			__setEventHandler();
			setStepSize(inStepSize);
			setTime(inTime);
		}
		
		/** Cette méthode permet de nommer le composant. Le nom est utilisé pour désigner l'émetteur d'un évènement de changement d'état fonctionnel.
		 *  @param inName Nom du composant. 
		 */
		
		public function setName(inName:String):void
		{
			__myName = inName;			
		}
		
		/** Ajuste l'heure de l'horloge.
		 *  @param inTime Valeur utilisée pour initialiser l'horloge. Deux formats sont utilisables :
		 *         o Un nombre entier compris entre 0 et 1439 (inclus), qui représente le nombre de minutes écoulées depuis 0h.
		 *         o Une chaîne "HH:MM".
		 *  @exception Si la valeur transmise à la fonction n'est pas correcte, alors une exception est lancée.
		 */
		
		public function setTime(inTime:String):void
		{
			var result:Object;
			var value:Number;
			var mod:Number;
			var regExpLiteral:RegExp = /^\s*(\d{1,2})\s*:\s*(\d{1,2})\s*$/;
			var regExpNumeric:RegExp = /^\s*(\d+)\s*$/;
			
			result = regExpLiteral.exec(inTime);
			if (result != null) { value = Number(result[1])*60 + Number(result[2]); } 
			else	{
						result = regExpNumeric.exec(inTime);
						if (result != null) { value = Number(result[1]); }
						else { throw new Error('Invalid time value: (' + inTime + ')'); } 
					}
			
			if (value >= 1440) { throw new Error('Time value out of range: ' + inTime); } 
			
			mod = value % __stepSize;
			__currentStep = (value - mod) / __stepSize;
			__format();
		}
		
		/** Ajuste la valeur de la marche entre deux valeurs successives des minutes.
		 *  @param inStepSize Valeur de la marche entre deux valeurs successives des minutes.
		 */
		
		public function setStepSize(inStepSize:Number):void
		{
			__stepSize  = inStepSize;
			__upperStep = ((1440 - (1440 % inStepSize)) / inStepSize) - 1;
		}
		
		/** Cette fonction permet d'ajuster l'horloge.
		 *  @param inValues Cet objet contient les paramètres d'ajustage. Les valeurs possibles sont les suivantes :
		 *         o time
		 *         o step
		 *         Veuillez vous référer à la documentation du constructeur afin d'obtenir la signification de ces paramètres.
		 *  @param inDispatchEvt Cet argument permet de spécifier si le composant doit envoyer un évènement suite à la mise à jour de l'heure.
		 */
		
		public function setValues(inValues:Object, inDispatchEvt:Boolean=true):void
		{
			var action:Boolean = false;
			if (inValues.hasOwnProperty('step')) { setStepSize(inValues.step); action = true; }
			if (inValues.hasOwnProperty('time')) { setTime(inValues.time);     action = true; }
			if (inDispatchEvt && action) { __dispatchEvent(); }
		}
		
		/** Cette méthode permet de récupérer l'heure sélectionnée par l'utilisateur.
		 *  @return La méthode renvoie un objet qui présente les propriétés suivantes :
		 *          o hour: Le nombre d'heures depuis 0h00.
		 *          o minute: Le nombre de minutes depuis le début de l'heure.
		 *          o value: Le nombre de minutes total depuis 0h00.
		 */
		
		public function getSelectedValues():Object
		{
			var minutes:Number = 0;
			var hour:Number    = 0;
			var minute:Number  = 0;
			
			minutes = __currentStep * __stepSize;
			minute  = minutes % 60;
			hour    = (minutes - minute) / 60;
			return {hour:hour, minute:minute, value:minutes}; 
		}
		
		/** Cette méthode rend le composant utilisable par l'utilisateur.
		 */
		
		public function enable():void
		{
			__upButton.enabled   = true;
			__downButton.enabled = true;
		}
		
		/** Cette méthode rend le composant inutilisable par l'utilisateur.
		 */
		
		public function disable():void
		{
			__upButton.enabled   = false;
			__downButton.enabled = false;
		}

		/** Cette méthode réinitialise le composant.
		 *  @param inValues Cet objet spécifie la liste des valeurs à réinitialiser.
		 *         La liste des propriétés attendues est la suivante :
		 *           o time
		 *           o step
		 *         Veuillez vous référer à la documentation du constructeur afin d'obtenir la signification de ces paramètres.
		 */
		
		public function reset(inValues:Object=null):void
		{
			if (inValues == null) { return; }
			setValues(inValues);
		}
		
		/** Cette méthode est utilisée pour déclarer les évènements traités par cette classe.
		 */		
		
		private function __setEventHandler():void
		{
			__evtHd.addEventHandler(__upButton,   FlexEvent.BUTTON_DOWN, __forwardClock);
			__evtHd.addEventHandler(__downButton, FlexEvent.BUTTON_DOWN, __rewindClock);
		}
		
		/** Cette méthode rend l'objet éligible à la destruction.
		 */
		
		public function destroy():void
		{
			__evtHd.removeAllEventHandlers();
		}
		
		/** Cette méthode crée l'interface utilisateur.
		 */
		
		private function __createTimePicker():void
		{
			var buttonVBox:VBox         = new VBox();
			var buttonUpSpacer:Spacer   = new Spacer();
			var buttonDownSpacer:Spacer = new Spacer();
			
			// Zone d'affichage de l'heure.
			__clockScreen.width = 60;
			__clockScreen.setStyle("textAlign", "center");
			// __clockScreen.setStyle("fontSize", "15");
			// __clockScreen.htmlText = '<b>00:00</b>';
			
			// Positionnement des boutons de réglage de l'heure.
			buttonUpSpacer.percentHeight   = 100;
			buttonUpSpacer.percentWidth    = 100;
			buttonDownSpacer.percentHeight = 100;
			buttonDownSpacer.percentWidth  = 100;
			__upButton.autoRepeat          = true;
			__upButton.height              = 13;
			__upButton.width               = 20;
			__downButton.autoRepeat        = true;
			__downButton.height            = 13;
			__downButton.width             = 20;
			buttonVBox.setStyle('paddingBottom', 0);
			buttonVBox.setStyle('paddingTop', 0);
			buttonVBox.setStyle('verticalGap', 0);
			buttonVBox.addChild(buttonUpSpacer);
			buttonVBox.addChild(__upButton);
			buttonVBox.addChild(__downButton);
			buttonVBox.addChild(buttonDownSpacer);
			
			// Allication des CSS
			__setCss();
			
			this.setStyle('verticalAlign', 'middle');
			this.addChild(__clockScreen);
			this.addChild(buttonVBox);
		}
		
		/**
		 * Cette méthode applique les CSS au composant.
		 */
		
		private function __setCss():void
		{
			if (__css != null)
			{
				if (__css.hasOwnProperty('clockText'))  	{ __clockScreen.styleName = __css.clockText; }
				if (__css.hasOwnProperty('clockButton'))	{ 
																__upButton.styleName   = __css.clockButton;
																__downButton.styleName = __css.clockButton;
															}
				if (__css.hasOwnProperty('clockBox'))    	{ this.styleName          = __css.clockBox; }
			}
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque l'utilisateur avance l'heure de l'horloge.
		 *  @param event Evènement reçut.
		 */
		
		private function __forwardClock(event:Event):void
		{
			if (__currentStep >= __upperStep) { return; }
			__currentStep += 1;
			__format();
			__dispatchEvent();
		}

		/** Ce gestionnaire d'évènement est exécuté lorsque l'utilisateur recule l'heure de l'horloge.
		 *  @param event Evènement reçut.
		 */
		
		private function __rewindClock(event:Event):void
		{
			if (__currentStep == 0) { return; }
			__currentStep -= 1;
			__format();
			__dispatchEvent();
		}
		
		/** Cette méthode formate la chaîne de caractères affichée par l'horloge.
		 */
		
		private function __format():void
		{
			var data:Object = getSelectedValues();
			__clockScreen.htmlText = '<b>' + __numberToString(data.hour)  + ':' + __numberToString(data.minute) + '</b>';
		}

		/** Cette fonction envoie l'évènement qui indique que l'heure a été modifiée.
		 */
		
		private function __dispatchEvent():void
		{
			// Il est important de ne pas exécuter cette action avant que le composant ne soit complètement initialisé.
			// Avant que le composant ne soit complètement initialisé, l'appel à la méthode "setName()" ne peut pas avoir été effectué.
			// Le troisième paramètre du constructeur de l'évènement doit valoir "true".

			if (initialized)
			{	
				if (__myName === null) { throw new Error('The component has no name.'); }
				dispatchEvent(new Action('Action', __myName, "TimeChanged", true));
				// trace ('TimePicker(' + __myName + '): TimeChanged');
			}
		}
		
		/** Retourne une chaîne de caractères qui représente l'heure, ou les minutes, sur deux caractères.
		 *  @param n Nombre entier qui représente l'heure ou les minutes.
		 */
		
		private function __numberToString(n:Number):String
		{
			if (n < 10) { return '0' + n.toString(); }
			return n.toString();
		}
		
	}
}

Quelques outils

/* Author: Denis BEURIVE */

package tools
{
	import flash.external.ExternalInterface;
	
	/** Cette classe contient des outils pour la manipulation de cookies.
	 */
	
	public class CookieUtils
	{
		/** Cette méthode permet d'envoyer un cookie au serveur.
		 *  @param name Nom du cookie.
		 *  @param value Valeur du cookie.
		 *  @param days Nombre de jours de validité du cookie. Le cookie expirera dans "days" jours.
		 */
		
		public static function setCookie(name:String, value:Object, days:int):void{
			if(!INITIALIZED)
				init();
			
			ExternalInterface.call("snw_setCookie", name, value, days);
		}
		
		/** Cette méthode renvoie la valeur d'un cookie, identifié par son nom.
		 *  @param name Nom du cookie.
		 *  @return La méthode renvoie un objet qui représente la valeur du cookie.	
		 */
		
		public static function getCookie(name:String):Object{
			if(!INITIALIZED)
				init();
			
			return ExternalInterface.call("snw_getCookie", name);
		}
		
		/** Cette méthode détruit le cookie identifié par son nom.
		 *  @param name Nom du cookie.
		 */
		
		public static function deleteCookie(name:String):void{
			if(!INITIALIZED)
				init();
			
			ExternalInterface.call("snw_setCookie", name, "", -1);
		}
		
		private static const FUNCTION_SETCOOKIE:String = 
            "document.insertScript = function ()" +
            "{ " +
                "if (document.snw_setCookie==null)" +
                "{" +
                    "snw_setCookie = function (name, value, days)" +
                    "{" +
                        "if (days) {"+
							"var date = new Date();"+
							"date.setTime(date.getTime()+(days*24*60*60*1000));"+
							"var expires = '; expires='+date.toGMTString();"+
						"}" +
						"else var expires = '';"+
						"document.cookie = name+'='+value+expires+'; path=/';" +
		            "}" +
                "}" +
            "}";
		
		private static const FUNCTION_GETCOOKIE:String = 
            "document.insertScript = function ()" +
            "{ " +
                "if (document.snw_getCookie==null)" +
                "{" +
                    "snw_getCookie = function (name)" +
                    "{" +
                        "var nameEQ = name + '=';"+
						"var ca = document.cookie.split(';');"+
						"for(var i=0;i < ca.length;i++) {"+
							"var c = ca[i];"+
							"while (c.charAt(0)==' ') c = c.substring(1,c.length);"+
							"if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);"+
						"}"+
						"return null;" +
		            "}" +
                "}" +
            "}";
     
            
        private static var INITIALIZED:Boolean = false;
		
		private static function init():void{
			ExternalInterface.call(FUNCTION_GETCOOKIE);
			ExternalInterface.call(FUNCTION_SETCOOKIE);
			INITIALIZED = true;
		}
		

	}
}

/* Author: Denis BEURIVE */

package tools
{
	import components.popups.HttpError;
	import components.popups.ServerError;
	import components.popups.WaitBox;
	
	import flash.display.DisplayObject;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	
	import gestionnaires.EventHandlerControler;
	
	import interfaces.IGhostInterface;
	
	import mx.core.IFlexDisplayObject;
	import mx.managers.PopUpManager;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.http.HTTPService;

	/** Cette classe implémente un service de téléchargement (séquentiel). Le composant peut-être configuré de deux façons :
	 *         Comportement "synchrone". Une boîte modale va bloquer l'interface utilisateur tant que le traitement ne sera pas entièrement terminé.
	 *         Comportement "asynchrone". Les interactions entre l'utilisateur et l'application sont permises.
	 * 
	 *  Il est également possible de déclencher l'exécution automatique d'une fonction à la fin du téléchargement.
	 *  Cette fonction peut être utilisée pour modifier le document téléchargé, afin de l'adapter à une utilisation spécifique.
	 *  Ou bien, cette fonction peut-être exécutée pour effectuer tous types d'actions.
	 * 
	 *  Remarque extraite de la documentation de FLEX :
	 *  Although you can load data into your application from other domains, these other domains must implement
	 *  an open crossdomain.xml file or add the domain that your SWF file is loaded from to their crossdomain.xml
	 *  file.
	 * 
	 *  @warning Il faut être prudent lors de l'utilisation des fonctions getDocument() et error().
	 *           Lorsque la fonction load() retourne, le document n'est pas encore téléchargé!!!
	 *           Pour exécuter une action dès que le document est téléchargé, il faut utiliser un greffon.
	 * 
	 *  @remark Ce composant présente la particularité de procéder à des téléchargements séquentiellement.
	 *          Si plusieurs téléchargements sont demandés, ils seront effectués l'un après l'autre.
	 *          Ce comportement est obtenu grâce à l'utilisation d'une propiété statique.
	 * 
	 *  @remark La machine virtuelle Flash ne fait qu'une seule chose : Exécuter des gestionnaires d'évènement, au grès des évènements.
	 *          L'exécution d'un gestionnaire d'évènement ne peut pas être interrompue (par un évènement).
	 *          Autrement dit, un gestionnaire d'évènement s'exécute de façon séquentielle, sans interruption.
	 * 
	 *  @note Amélioration possible : Autoriser les téléchargements simultanés depuis des sources distinctes.
	 */
	
	[ Event( name="LoaderEvt", type="HttpLoaderEvt") ]
	public class HttpLoader extends EventDispatcher implements IGhostInterface
	{
		private var __evtHd:EventHandlerControler = new EventHandlerControler();
		private var __result:Object               = null;
		private var __error:Boolean               = false;
		private var __plugin:Function             = null;
		private var __synchro:Boolean             = true;
		private var __http:HTTPService            = new HTTPService();
		private var __popup:IFlexDisplayObject;
		private var __parent:DisplayObject;

		/** File d'attente de téléchargement, commune à tous les objets de téléchargement.
		 */

		static private var __downloads:Array = null;

		/** Crée un chargeur de document via HTTP.
		 *  @param inParent Ce paramètre définit le composant d'affichage utilisé pour attacher, les menus surgissant.
		 */
		
		public function HttpLoader(inParent:DisplayObject, target:EventDispatcher=null)
		{
			super(target);
			
			// On s'assure que la file de téléchargements est instanciée une seule fois!
			if (__downloads == null) { __downloads = new Array(); }
			__parent = inParent;
			__setEventHandler();
		}
		
		/** Cette méthode est utilisée pour déclarer les évènements traités par cette classe.
		 */	

		private function __setEventHandler():void
		{
			__evtHd.addEventHandler(__http, FaultEvent.FAULT, __httpErrorPopup);
			__evtHd.addEventHandler(this,   'LoaderEvt',      __loadNow);
		}
		
		/** Cette méthode lance le prochain téléchargement dans la liste des téléchargements planifiés.
		 *  @param event Cet évènement est envoyé pour déclencher un téléchargement.
		 */
		
		private function __loadNow(event:HttpLoaderEvt):void
		{
			var values:Object;
		
			trace(' ');
			trace ('HTTPLoader:__loadnow(): action = ' + event.getAction());
			trace ('HTTPLoader:__loadnow(): Download stack size is ' + __downloads.length);
			// Si la liste des téléchargements planifiés est vide, on ne fait rien.
			if (__downloads.length == 0) { return; }
		
			// On lance le prochain téléchargement planifié.
			values = __downloads[0];
			trace ('HTTPLoader:__loadnow(): Loading URL ' + values.url);
			__error   = false;
			__result  = null;
			__plugin  = values.plugin;
			__synchro = values.synchro;
			
			// Affichage de la boîte modale qui oblige l'utilisateur à attendre la fin de l'opération.
			if (__synchro)
			{
				__popup = PopUpManager.createPopUp(__parent, components.popups.WaitBox, true);
				PopUpManager.centerPopUp(__popup);
			}
			
			// On envoie au serveur la demande de la liste des codes postaux.
			__evtHd.addEventHandler(__http, ResultEvent.RESULT, __processLoadedDocument);
			__http.url          = values.url;  
			__http.method       = values.method;
			__http.resultFormat = values.resultFormat;
			__http.send(values.values);
		}
		
		/** Cette méthode planifie le téléchargement d'un document.
		 *  Le téléchargement n'est pas lancé immédiatement : Un évènement est envoyé pour demander le téléchargement.
		 *  Si un évènement de téléchargement est déjà en cours de traitement, l'évènement sera placé en file d'attente.
		 *  De cette façon, les téléchargements sont séquentiels.
		 *  @param inUrl URL vers le document à télécharger.
		 *  @param inPlugin Fonction à exécuter lorsque le document a été chargé.
		 *         Cette fonction doit accepter un paramètre, le document chargé.
		 *         Et il doit renvoyer un objet (éventuellement, la valeur null).
		 *         Prototype : function plugin(inValue:Object):Object.
		 *         Si la valeur renvoyée est différente de la valeur null, alors la valeur renvoyée sera affectée au document téléchargé.
		 *         Pour récupérer le "nouveau" document, on pourra appeler les fonctions suivantes : error(), suivi de getDocument().
		 *  @param inFormat Ce paramètre indique sous quelle forme doit être présenté le document téléchargé.
		 *         Pour connaître les valeurs possibles, veuillez consulter la documentation de la classe "HTTPService" (propriété "resultFormat").
		 *  @param inSyncronous Ce paramètre permet de spécifier le comportement du chargeur.
		 *         La valeur "true" indique que le chargeur est "synchrone". Une boîte modale va bloquer l'interface utilisateur tant que le traitement ne sera pas entièrement terminé.
		 *         La valeur "false" indique que le chargeur est "asynchrone". Les interactions entre l'utilisateur et l'application sont permises.
		 *  @param inValues Cet objet contient une liste de valeurs à envoyer au serveur, dans la requête HTTP.
		 *  @param inMethod Méhode utilisée ("GET" ou "POST").
		 */
		
		public function load(inUrl:String, inPlugin:Function=null, inFormat:String='text', inSyncronous:Boolean=true, inValues:Object=null, inMethod:String='GET'):void
		{
			trace(' ');
			trace('HTTPLoader:load() ' + inUrl);
			
			__downloads.push( {	url:inUrl,
								method:inMethod,
								resultFormat:inFormat,
								values:inValues,
								plugin:inPlugin,
								synchro:inSyncronous } );
			
			trace('HTTPLoader:load() Download stack size is ' + __downloads.length);
			// On envoie un évènement pour démarrer le premier téléchargement.
			if (__downloads.length == 1)
			{
				trace('HTTPLoader:load() First download => Disparch event [NewDownload]');
				dispatchEvent(new HttpLoaderEvt('LoaderEvt', this, "NewDownload", true));
			}
		}

		/** Ce gestionnaire d'évènement est appelé lorsque le composant HTTP reçoit la réponse du serveur.
		 *  @param event Évènement lancé par le service HTTP lorsque la réponse du serveur est reçue.
		 */

		private function __processLoadedDocument(event:Event):void
		{
			var popup:IFlexDisplayObject;
			var res:Object;
		
			trace(' ');
			trace ('HTTPLoader:__processLoadedDocument(): Got the document!');
			
			// On commence par retirer ce gestionnaire d'évènement.
			__evtHd.removeEventHandler(__http, ResultEvent.RESULT);
			
			// On extrait la réponse du serveur.
			try	{ __result = __http.lastResult; }
			catch (err:Error)
			{
				__error  = true;
				trace (err.message);
				if (__synchro) { PopUpManager.removePopUp(__popup); }
				popup = PopUpManager.createPopUp(__parent, components.popups.ServerError, true);
				PopUpManager.centerPopUp(popup);
			}
			
			// Il faut libérer les ressources.
			__http.clearResult();

			// On exécute le greffon, s'il est défini.
			if ((__plugin != null) && (! __error)) { res = __plugin(__result); if (res != null) { __result = res; /* trace ("HttpLoader res = " + res.toString()); trace('Value updated'); */ }; }
			if ((! __error) && __synchro) { PopUpManager.removePopUp(__popup); }
			
			// Le téléchargement a réussi.
			// On dépile le téléchargement qui vient de se terminer.
			// Puis, on lance le prochain dans la liste.
			trace ('HTTPLoader:__processLoadedDocument(): Dépile un téléchargement');
			__downloads.shift();
			dispatchEvent(new HttpLoaderEvt('LoaderEvt', this, "DownloadSucceed", true));
		}

		/** Cette méthode rend le composant éligible à la destruction.
		 */		
		
		public function destroy():void
		{
			__evtHd.removeAllEventHandlers();
		}
		
		/** Ce gestionnaire d'évènement est utilisé pour signaler les erreurs HTTP.
		 *  @param event Évènement lancé par le service HTTP lorsqu'une erreur se produit.
		 */

		private function __httpErrorPopup(event:Event):void
		{
			var popup:IFlexDisplayObject;
			trace(' ');
			trace ("Got an error!");
			if (__synchro) { PopUpManager.removePopUp(__popup); }
			popup = PopUpManager.createPopUp(__parent, components.popups.HttpError, true);
			PopUpManager.centerPopUp(popup);
			__evtHd.removeEventHandler(__http, ResultEvent.RESULT);
			
			// Le téléchargement a échoué.
			// On dépile le téléchargement qui vient de se terminer.
			// Puis, on lance le prochain dans la liste.
			__downloads.shift();
			dispatchEvent(new HttpLoaderEvt('LoaderEvt', this, "DownloadFailed", true));
		}
		
		/** Cette méthode renvoie le document téléchargé.
		 *  @return La méthode renvoie un objet qui contient le document téléchargé.
		 *  @warning Veillez à ne pas appeler cette méthode avant que le document ne soit chargé!
		 */

		public function getDocument():Object { return __result; }
		
		/** Cette méthode permet de savoir si une erreur s'est produite.
		 *  @return Si une erreur est survenue, la méthode renvoie la valeur "true".
		 *          Sinon, la méthode renvoie la valeur "false".
		 *  @warning Veillez à ne pas appeler cette méthode avant que le document ne soit chargé!
		 */
		
		public function error():Boolean { return __error; }
	}
	
	
	
}

import flash.events.Event;

/** Cette classe définit un évènement spécifique aux objets de la classe "HTTPLoader".
 *  @remark Cette classe est une classe interne. Cela signifie qu'elle n'est accessible que depuis les classes définies dans ce fichier.
 */

internal class HttpLoaderEvt extends Event
{
		private var __booleanBubbles:Boolean;
		private var __booleanCancelable:Boolean;
		private var __source:Object;
		private var __action:String;
		private var __stringType:String;
	
		/** Crée un évènement de type "HttpLoaderEvt".
		 *  @param source Cet objet représente le lanceur d'évènement.
		 *  @param action Cette chaîne représente le type d'action signalé par cet évènement.
		 */
	
		public function HttpLoaderEvt(type:String, source:Object, action:String, bubbles:Boolean=false, cancelable:Boolean=false)
		{
			super(type, bubbles, cancelable);
			__stringType        = type;
			__booleanBubbles    = bubbles;
			__booleanCancelable = cancelable;
			__source            = source;
			__action            = action;
		}

		override public function clone():Event
		{
			return new HttpLoaderEvt(__stringType, __source, __action, __booleanBubbles, __booleanCancelable);
		}
		
		public function getAction():String { return __action; }
		
		public function getSource():Object { return __source; }
}

/* Author: Denis BEURIVE */

package tools
{
	import mx.collections.XMLListCollection;
	
	public class DataProviderTools
	{
		/** Cette fonction permet de déterminer l'index d'un élément dans une liste de sélection de type "ComboBox".
		 *  @param inAttributName Nom de l'attribut associé à l'élément recherché.
		 *  @param inAttributValue Valeur de l'attribut associé à l'élément recherché.
		 *  @param inProvider Liste d'éléments présents dans la liste de sélection.
		 *  @param inDefaultReturnValue Dans le cas où l'élément ne serait pas dans la liste de sélection, ce paramètre définit la valeur d'index à renvoyer.
		 *  @return La fonction retourne l'index de l'élément dans la liste de sélection.
		 *          Cette valeur peut être égale à la valeur "inDefaultReturnValue" fournie en paramètre, si l'élément n'est pas trouvé dans la liste.
		 *  @note Chaque élément de la liste des éléments présents dans le composant de sélection doit comporter les attributs suivants : "label" et "data".
		 */

		public static function getComboBoxDataProviderIndex(inAttributName:String, inAttributValue:String, inProvider:Object, inDefaultReturnValue:uint=0):uint
		{
			var inList:XMLListCollection = XMLListCollection(inProvider);
			
			// note: 
			// XMLListCollection = Interface spéciale autour d'un composant de type XMLList.
			//                     Une XMLListCollection est une XMLList.
			// XMLList = Tableau d'éléments XML.
			//           Un élément peut être n'importe quelle information du document XML (y compris un attribut!).
			
			for (var i:uint=0; i<inList.length; i++)
			{
				// Note: xml.@data <=> xml.attribute('data')
				if (inList[i].attribute(inAttributName) == inAttributValue) { return i; } 
			}
			
			return inDefaultReturnValue;
		}



	}
}

/* Author: Denis BEURIVE */

package tools
{
	import flash.events.Event;
	
	import mx.core.Container;
	import mx.effects.AddChildAction;
	import mx.effects.Effect;
	import mx.effects.RemoveChildAction;
	import mx.effects.Sequence;
	import mx.events.EffectEvent;
	
	/** Cette classe permet de créer des transitions entre des états, sur une scène.
	 *  Un état se caractérise par l'affichage d'un objet dans un conteneur (la scène).
	 *  Une transition de l'état "E1" vers l'état "E2" se caractérise par :
	 *  o La disparition de l'objet associé à l'état "E1".
	 *  o L'apparition de l'objet associé à l'état "E2".
	 *  Note : La disparition d'un objet de la scène est associée à une transformation.
	 *         Une transformation est une suite d'effets (listés dans un tableau). 
	 */
	
	public class TransitionMaker
	{
		private var __scene:Container;
		private var __currentState:String;
		private var __nextState:String;
		private var __statesList:Array;
		private var __sequence:Sequence;
		private var __statesIndex:Object = new Object();
		private var __busy:Boolean       = false;
		
		/** Crée un objet de gestion des transitions.
		 *  @param inScene Composant sur lequel sont jouées les transitions.
		 *  @param inStates Ce tableau contient des éléments de type "Object".
		 *         Chaque élément représente un état.
		 *         Un état, dans le contexte de cette classe, est associé à un composant affiché sur la scène.
		 *         Le passage entre deux états successifs définit une transition.
		 *         Une transition correspond à la disparition du composant courant et à l'apparition du composant associé au nouvel état.
		 *         Les propriétés des objets qui représentent les éléments du tableau sont :
		 *         o name: Le nom de l'état (qui correspond à l'affichage d'un composant sur la scène).
		 *         o display: Objet d'affichage qui caractérise l'état.
		 *         o appear:  Cet attribut est un tableau d'objets de types "Effect".
		 *                    Les effets placés dans le tableau seront joués, les un après les autres, lors de l'apparition du composant. 
		 *         o disappear: Cet attribut est un tableau d'objets de types "Effect". 
		 *                      Les effets placés dans le tableau seront joués, les un après les autres, lors de la disparition du composant.
		 *  @param inCurrentState Nom de l'état courant (par défaut, le premier de la liste).
		 */
		
		public function TransitionMaker(inScene:Container, inStates:Array, inCurrentState:String=null)
		{
			if (inStates.length < 2) { throw new Error('The list of states contains ' + inStates.length + ' elements! (it should contain, at least, 2 elements)'); }
			__statesList = inStates;
			__scene      = inScene;
			if (inCurrentState == null) { __currentState = inStates[0].name; } else { __currentState = inCurrentState; }
			__createIndex();
		}
		
		/** Cette fonction crée un index de la liste des états.
		 *  L'index associe les noms des états à leurs positions dans la liste des états.
		 */
		
		private function __createIndex():void
		{
			var name:String;
			
			for (var i:Number=0; i<__statesList.length; i++)
			{
				name = __statesList[i].name;
				if (__statesIndex.hasOwnProperty(name)) { throw new Error('Duplicate state name ' + name); }
				__statesIndex[name] = i;
			}
			if (! __statesIndex.hasOwnProperty(__currentState)) { throw new Error('Unknown initial state: ' + __currentState); }
		}
		
		/** Cette méthode fait passer la scène d'un état à un autre.
		 *  o La séquence de dispariation de l'état courant est joué sur le composant présent sur la scène.
		 *  o Le composant présent sur la scène disparaît.
		 *  o Le composant associé à l'état de destination apparaît sur la scène.
		 *  o La séquence d'apparition de l'état courant est joué sur le composant qui vient d'apparaître.
		 *  @param inName Nom de l'état de destination.
		 */
		
		public function goToState(inName:String):Boolean
		{
			var currentObject:Object;
			var nextObject:Object;
			var addAction:AddChildAction;
			var removeAction:RemoveChildAction;
			var e:Effect;

			if (__busy)                   { trace ('Rejected - I am busy!'); return false; }
			if (inName == __currentState) { trace ('Rejection - Same destination state!'); return false; }

			__busy       = true;	
			__nextState  = inName;
			__sequence   = new Sequence();
			
			currentObject = __getStateByName(__currentState);
			nextObject    = __getStateByName(__nextState);
			removeAction  = new RemoveChildAction(currentObject.display);
			addAction     = new AddChildAction(nextObject.display);
			addAction.relativeTo = __scene;
						
			// Construction de la transformation.
			for each (e in currentObject.disappear) { e.target = currentObject.display; __sequence.addChild(e); }
			__sequence.addChild(removeAction);
			__sequence.addChild(addAction);
			for each (e in nextObject.appear) { e.target = nextObject.display; __sequence.addChild(e); }
			
			// Activation de la transformation.
			__sequence.addEventListener(EffectEvent.EFFECT_END, __sequenceDone);
			__sequence.play();
			return true;
		}

		/** Cette fonction renvoie l'index d'un état, désigné par son nom, dans la liste des états.
		 *  @param inName Nom de l'état.
		 */

		private function __getStateByName(inName:String):Object
		{
			return  __statesList[__statesIndex[inName]];
		}
		
		/** Ce gestionnaire d'évènement est exécuté lorsque la séquence qui s'applique à la scène est terminée. 
		 *  @param event Évènement envoyé lorsque la séquence qui s'applique à la scène est terminée. 
		 */
		
		private function __sequenceDone(event:Event):void
		{
			trace ('Got event!');
			__sequence.removeEventListener(EffectEvent.EFFECT_END, __sequenceDone);
			__busy     = false;
			__sequence = null;
		}
		
	}
}