/* **************** CLASSE JAVA SCRIPT FORMULAIRE **************************** #
	 	importer le code dans la page
		<script src="../js/validator.js"></script>
		
		ATTENTION : 
		* le reste du code dédié à la validation ne doit pas se placer à l'intérieur
		  de la même balise <script></script>
		
		* la déclaration d'un objet Formulaire doit se faire aprés le formulaire HTML
		
		* les méthodes sont attachés aux différents évènements liés à la manipulation des contrôles
		il est déconseillé d'affecter d'autres fonctions à ces évènements
			* onblur pour les text et select
			* onclic pour les radios et checkbox
	
	Instanciation du formulaire :
	--------------------------------------------------------------------------------------------------------------------
	
		var form_obj = NEW_Validator(id[], extra_validation]);
		* name			: attribut id d'un formulaire existant
		* extra_validation	: nom d'une fonction qui sera appellée à la fin de la validation du formulaire
							  cette fonction doit retourner obligatoirement true si aucune erreur ne s'est 
							  produite sinon un message "erreur non déterminé s'affichera"
		
		Une fonction de validation supplémentaire doit lever les erreurs qui se produisent grâce à la méthode 
		* form_obj.raiseError('mon message d\'erreur');
		
		Elle doit retourner un booléen. Si elle retourne vrai en ayant levé des erreurs, la validation globale échoue.
		Si elle retourne faux sans avoir levé d'erreur, un message indiquant une erreur inconnue sera affiché.
		
		Dans cette fonction de validation, il est possible d'accéder aux valeurs présentes dans les contrôles :
		* form_obj.field('nom_champ').value()
		
		Accéder aux nombre d'erreurs levées par la validation :
		* form_obj.errorsCount()
		
		Si une classe CSS error est déclarée, elle sera appliquée aux labels 
		correspondant aux champs mal renseignés
		
	
	Ajout de controles au formulaire :
	--------------------------------------------------------------------------------------------------------------------
		form_obj.addField(name, required, data_type, data_format)
		* name				: nom du formulaire HTML auquel s'appliquera le validateur
		* required			: 1 si le champ est obligatoire 0 sinon
		* data_type			: type de donnée requis
		* data_format 		: formatage spécifique à appliquer à un champ texte
		
	Méthode setLanguage(lang) [à implémenter]
	--------------------------------------------------------------------------------------------------------------------
		permet d'exprimer les messages en anglais. Paramètre : "fr", "en"
		
	Types de données : 
	--------------------------------------------------------------------------------------------------------------------
		* integer			: valide un entier
		* decimal			: valide un nombre décimal
		* date				: valide une date dans
		* zipcode			: valide un code postal
		* email				: valide une adresse email
		* telnum			: valide un numéro de tel 
	
	Formatages : 
	--------------------------------------------------------------------------------------------------------------------
		* lower				: passe le texte en minuscules
		* upper				: passe le texte en majuscules
		* ucfirst			: passe la première lettre du texte en majuscule
		* ucwords			: passse la première lettre de chaque mot en majuscules
		* telnum			: formate le numéro de téléphone en groupant
	
	à faire :
	--------------------------------------------------------------------------------------------------------------------
	- éviter l'affichage à la suite du même message d'erreur lors d'une erreur de format
	et immédiatement aprés le même message lors de la validation du formulaire
	- types : texte ? contraintes,  
 */

 /********** Objet utilisés pour la validation de formulaires ***************/


 /* constantes d'état */
   var SAISIE_EN_COURS		= 1;
   var VALIDATION_EN_COURS	= 2;
   var VALIDATOR_DEBUG		= false;

 /************************************************************************** #
                               Objet Formulaire                              #
 *************************************************************************** #
                       construction de l'objet formulaire					*/

 	validator_vars = new Array();
 	function NEW_Validator(name, extra_validation){
 		i = validator_vars.length;
 		validator_vars[i]	= new Validator(name, extra_validation);
 		return validator_vars[i];
 	}
 	
 	function GET_ValidatorReference(name){
 		if (VALIDATOR_DEBUG) {
 			alert('recherche une référence sur ' + name);
 		}
 		nb = validator_vars.length;
 		for (i = 0; i < nb && validator_vars[i].name != name; i++) {;}
 		if (i < nb) {
 			return validator_vars[i];
 		} else {
 			alert('impossible de trouver le validateur pour le formulaire ' + name + ' ' + typeof(name));
 			return null;
 		}
 	}
 	
 	function VALIDATE_Field(form_name, field_name){
 		//alert('112 : ' + typeof(form_name) + ' ' + form_name);
 		obj_validator = GET_ValidatorReference(form_name);
 		if (typeof(obj_validator) == 'object') {
 			nb = obj_validator.fields.length;
 			for (i = 0; i < nb && obj_validator.fields[i].name != field_name; i++) {;}
 			if (i < nb) {
 				return obj_validator.fields[i].validate(1);
 			}
 		} else {
 			alert('impossible de trouver le validateur pour le formulaire ' + form_name);
 			return false;
 		}
 	}
 	
 	function FORMAT_FieldData(form_name, field_name){ 		
 		obj_validator = GET_ValidatorReference(form_name);
 		if (typeof(obj_validator) == 'object') {
 			nb = obj_validator.fields.length;
 			for (i = 0; i < nb && obj_validator.fields[i].name != field_name; i++) {;}
 			if (i < nb) {
 				return obj_validator.fields[i].format(1);
 			}
 		} else {
 			alert('impossible de trouver le validateur pour le formulaire ' + form_name);
 			return false;
 		}
 	}
 	
 	
 	
 	function VALIDATE_Form(form_name){ 		
 		obj_validator = GET_ValidatorReference(form_name);
 		if (obj_validator != null){
 			return obj_validator.validate();
 		} else {
 			alert('formulaire introuvable ' + form_name);
 			return false;
 		}
 	}
 
	function Validator(name, extra_validation){
      // Definition des propriétés
         this.prototype				= null;
         this.name					= name;
         this.action				= "";
         this.changed				= false;
         
         this.fields 				= new Array();
         this.fieldsArray			= new Array();
         this.errorMsg	 			= ""; // message d'erreur de validité des données
         this.requiredDataMsg		= "";
         this.language				= "fr";
         this.nbErrors				= 0;
		 this.extraValidation		= (typeof(extra_validation) != 'undefined' && extra_validation != '' ? extra_validation : null);

      // définition des méthodes
         this.addField				= Validator_addField;
         this.validate				= Validator_validate;
         this.setLanguage			= Validator_setLanguage;
		 this.addCheck				= Validator_addCheck;
		 this.field					= Validator_getField;
		 this.raiseError			= Validator_raiseError;
		 this.errorsCount			= Validator_errorsCount;
		 
		 this.translations = new Array();		 
		 this.translations['fr']	= new Array();
		 this.translations['fr']['validation-fails']	= 'Le formulaire contient %s erreur(s) :\n';
		 this.translations['fr']['required']			= 'Le champ "%s" est obligatoire';
		 this.translations['fr']['data-type']			= 'Le champ "%s" doit contenir %s';
		 
		 this.translations['fr']['type-integer']		= 'un nombre entier';
		 this.translations['fr']['type-decimal']		= 'un nombre décimal';
		 this.translations['fr']['type-date']			= 'une date (jj/mm/aaaa)';
		 this.translations['fr']['type-zipcode']		= 'un code postal';
		 this.translations['fr']['type-email']			= 'une adresse email (utilisateur@domaine.com)';
		 this.translations['fr']['type-telnum']			= 'un numéro de téléphone';
		 
         if (document.getElementById(this.name) == null) {
			alert("Le formulaire specifie " + this.name + " est introuvable.");
         }
         
		if (VALIDATOR_DEBUG) {
 			alert('lie l\'évènnement onsubmit du formulaire "' + this.name + '" à la fonction de validation');
		}
		
		eval('document.getElementById("' + this.name + '").onsubmit = function (){return VALIDATE_Form(\"'+ this.name + '\");}');
		
   }
   
	function Validator_addCheck(StrFunction){
		if (StrFunction != "") {
			this.extraValidation = StrFunction;
		}
	}

	function Validator_setLanguage(lang){
		
	}
	
	function Validator_getField(name){
		nb = this.fields.length;
		for (i = 0; i < nb; i++) {
			if (this.fields[i].name == name) {
				return this.fields[i];
			}
		}
	}

	/*
	* Ajoute un contrôle dont le nom des fourni à l'objet Validator
	* @param name
	* @param required
	* @param data_type
	* @param data_type_msg
	* @param label [inutile d'indiquer un libellé si un controle <label for="name">libellé</label> existe]
	*
	*/
	function Validator_addField(name, required, data_type, data_format) {
		var added		= false;
		var i			= 0;
		
		if (document.getElementsByName(name).length == 0) {
			alert("Controle specifie non trouve : " + name);
			return false;
		}
		
		if (!(required === true || required === false)) {
			alert('paramètre "required" incorrect, booléen attendu');
			return false;
		}
		if (VALIDATOR_DEBUG) {
 			alert('ajoute le champ ' + name);
		}
		this.fields[this.fields.length]	= new FormField(this, name, required, data_type, data_format);
	}

// --------------------------------------------------------------------------- #
//                     méthodes de controle des saisies                        #
// --------------------------------------------------------------------------- #

	function Validator_validate() {
		if (VALIDATOR_DEBUG) {
 			alert('Exécute validate');
		}
		this.errorMsg = '';
		this.nbErrors	= 0;
		var nb			= this.fields.length;
		
		for (k = 0; k < nb; k++) {
			if (VALIDATOR_DEBUG) {
 				alert('appel de la méthode validate() du champ "' + this.fields[k].name + '" dans validate()');
			}
			if (!this.fields[k].validate()){
				if (VALIDATOR_DEBUG) {
 					alert('ECHEC de la méthode validate() du champ "' + this.fields[k].name + '" erreur : ' + this.fields[k].errorMsg); //this.fields[i].errorMsg
				}
				this.errorMsg	+= this.fields[k].errorMsg + "\n";
				this.nbErrors++;
			}
			if (VALIDATOR_DEBUG) {
 				alert('msg erreur Validator : ' + this.errorMsg);
			}
		}
		
		if (VALIDATOR_DEBUG) {
 			alert('nombre d\'erreurs détectées "' + this.nbErrors + '" dans validate()');
		}
		
		nb_errs_tmp = this.nbErrors;
		var res_val		= true;
		if (this.extraValidation != null) {
			eval('res_val = ' + this.extraValidation + '(this);');
		}
		
		if (!res_val) {
			/* si la validation personnalisée a retourné faux sans indiquer l'erreur */
			if (this.nbErrors == nb_errs_tmp) {
				this.nbErrors++; /* possibilité de retourner faux sans ajouter de message d'erreur */
				//this.raiseError('erreur non déterminée');
			}
		}
		
		if (this.nbErrors > 0) {
			if (this.errorMsg != '') {
				this.errorMsg = this.translations['fr']['validation-fails'].replace('%s', this.nbErrors) + this.errorMsg;
				alert(this.errorMsg);
			}
		}
		if (VALIDATOR_DEBUG) {
 			alert('validate s\'apprète à retourner la valeur "' + (ret_val ? 'true' : 'false') + '"');
		}
		return (this.nbErrors == 0);
	}
	
	function Validator_raiseError(msg){
		if (typeof(msg) != 'undefined' && msg != null && msg != '') {
			this.nbErrors++;
			this.errorMsg	+= msg + "\n";
		}
	}
	
	function Validator_errorsCount(){
		return this.nbErrors;
	}


// *************************************************************************** #
//                               Objet Champs                                  #
// *************************************************************************** #
	function FormField(frm_object, name, required, data_type, data_format){
		this.form				= frm_object;
		
		if (VALIDATOR_DEBUG) {
 			alert('instancie un objet pour le champ ' + name);
		}
		
		/* configuration des méthodes de contrôle des différents types de données */
		this.dataTypes = new Array();
		this.dataTypes['integer']	= 'field_check_integer';
		this.dataTypes['decimal']	= 'field_check_decimal';		
		this.dataTypes['date']		= 'field_check_date';
		this.dataTypes['zipcode']	= 'field_check_zipcode';
		this.dataTypes['email']		= 'field_check_email';
		this.dataTypes['telnum']	= 'field_check_telnum';
		
		this.dataFormats = new Array();
		this.dataFormats['upper']	= 'field_format_upper';
		this.dataFormats['lower']	= 'field_format_lower';
		this.dataFormats['ucfirst']	= 'field_format_ucfirst';
		this.dataFormats['ucwords']	= 'field_format_ucwords';
		this.dataFormats['telnum']	= 'field_format_telnum';
		
		this.name				= name; //, nom qui permet d'accéder à ses propriétés (prop. HTML name)
		this.required			= required; // de type booléen, obligatoire ou non
		this.dataType			= typeof(this.dataTypes[data_type]) != 'undefined' ? data_type : null;
		this.dataFormat			= typeof(this.dataFormats[data_format]) != 'undefined' ? data_format : null
		this.label				= ''; // de type texte, désignation conviviale
		this.errorMsg			= '';
		
		if (VALIDATOR_DEBUG && typeof(data_type) != 'undefined' && data_type != '' && typeof(this.dataTypes[data_type]) == 'undefined') {
			alert('type de donnée "' + data_type + '" non défini');
		}
		
		if (VALIDATOR_DEBUG && typeof(data_format) != 'undefined' && data_format != '' && typeof(this.dataFormats[data_format]) == 'undefined') {
			alert('format de donnée "' + data_format + '" non défini');
		}
		
		
		
		// définition des méthodes
		this.checkType			= Field_checkType;
		this.value				= Field_getCurrentValue;
		this.validate			= Field_validate;
		this.format				= Field_FormatData;
		
		this.controleType		= '';
		
		switch (document.getElementsByName(this.name)[0].nodeName.toLowerCase()) {
		case 'input' :
			this.controleType	= document.getElementsByName(this.name)[0].type
		break;
		case 'textarea':
		case 'select' :
			this.controleType = document.getElementsByName(this.name)[0].nodeName.toLowerCase();
		break;
		}
		
		reg = new RegExp(/_/g);
		var container_id = this.name.replace(reg, '-');
		
		/* tente d'identifier une valeur de libellé pour le contrôle */
		if (this.controleType == 'radio') {
			obj_fieldset = document.getElementById('radios-set-row-' + container_id);
			if ((obj_fieldset != null) && obj_fieldset.hasChildNodes() && obj_fieldset.getElementsByTagName('span').length > 0) {
				this.labelObject = obj_fieldset.getElementsByTagName('span')[0];
				this.label 		 += this.labelObject.childNodes[0].nodeValue;
			}
		} else {
			labels	= document.getElementsByTagName('label');
			nb		= labels.length;		
			for (i = 0; i < nb; i++){
				if (labels[i].attributes.getNamedItem('for') !== null && labels[i].attributes.getNamedItem('for').nodeValue == name) {
					if (labels[i].childNodes != 'undefined') {
						var nb_childnodes = labels[i].childNodes.length;
						for (j = 0; j < nb_childnodes; j++) {
							if (labels[i].childNodes[j].nodeType == 3) {
								this.label 			+= labels[i].childNodes[j].nodeValue;
								this.labelObject	= labels[i];
							} else {
								/* si un tag est présent dans le label */
								if (labels[i].childNodes[j].hasChildNodes() && labels[i].childNodes[j].childNodes[0].nodeType == 3) {
									this.label += labels[i].childNodes[j].childNodes[0].nodeValue;
								}
							}
						}
					}
					break;
				}
			}
		}
		
		
		
		/* affiche une erreur si aucun label n'a été trouvé pour le champ */
		if (typeof(this.labelObject) == 'undefined') {
			alert('aucun label n\'a été trouvé pour le champ ' + this.name + ' (<label for="' + this.name + '">)');
			return false;
		}
		
		if (this.controleType == '') {
			alert('type de contrôle non identifié ' + document.getElementsByName(this.name)[0].nodeName);
		}

		obj = document.getElementsByName(this.name);
		nb	= obj.length;
		if (VALIDATOR_DEBUG) {
 			alert('type de contrôle ' + this.controleType + 'trouvé ' + nb);
		}
		
		
		required_tag = document.createElement('span');
		if (this.required) {
			required_tag.appendChild(document.createTextNode('*'));
		}
		required_tag.setAttribute('class', 'required');
		required_tag.setAttribute('className', 'required');
		
		if (nb != 0) {
			for (i = 0; i < nb; i++) {
				switch (this.controleType) {
				case 'text':
				case 'select':
				case 'password':
				case 'textarea':
					if (VALIDATOR_DEBUG) {
				 		alert('ajoute les evts ');
					}
					str_onblur = 'document.getElementsByName("' + this.name + '")['+ i +'].onblur = function(){';
					str_onblur += 'VALIDATE_Field("' + this.form.name + '", "' + this.name + '");';
					str_onblur += 'FORMAT_FieldData("' + this.form.name + '", "' + this.name + '");';
					str_onblur += '}';
					eval(str_onblur);
					
					if (this.controleType == 'select') {
					document.getElementById('select-one-row-' + container_id).appendChild(required_tag);
					} else {
						if (this.controleType == 'textarea' ) {
						document.getElementById('textarea-row-' + container_id).appendChild(required_tag);
						} else {
						document.getElementById('text-row-' + container_id).appendChild(required_tag);
						}
					}					
				break;
				case 'radio':
					str_onblur	= 'document.getElementsByName("' + this.name + '")['+ i +'].onblur = function(){';
					str_onblur += 'VALIDATE_Field("' + this.form.name + '", "' + this.name + '");';				
					str_onblur += '}';
					eval(str_onblur);
					document.getElementById('radios-set-row-' + container_id).appendChild(required_tag);
				break;
				case 'checkbox':
					str_onclick	= 'document.getElementsByName("' + this.name + '")['+ i +'].onclick = function(){';
					str_onclick += 'VALIDATE_Field("' + this.form.name + '", "' + this.name + '");';				
					str_onclick += '}';
					eval(str_onclick);
					if (this.controleType == 'radio') {
						document.getElementById('radios-set-row-' + container_id).appendChild(required_tag);
					} else {
						document.getElementById('checkbox-row-' + container_id).appendChild(required_tag);
					}
				break;
				}
			}
		}
	}

// --------------------------------------------------------------------------- #
//                          méthodes de controle des saisies                   #
// --------------------------------------------------------------------------- #
	function Field_FormatData(){
		if (this.controleType == 'text' && this.dataFormat != null) {
			fct_format	= (this.dataFormats[this.dataFormat]);
			value		= this.value();
			eval('res = ' + fct_format + '("' + (value == null ? '' : value) + '");');
			document.getElementsByName(this.name)[0].value = (res == null ? '' : res);
		}
	}


	function Field_checkType(display_msg){
		if (VALIDATOR_DEBUG) {
 			alert('valide le type de données du champ : "' + this.name + '"\ntype attendu : "' + this.dataType + '" fonction appellée "'+ this.dataTypes[this.dataType] + '"');
		}
		
		if (typeof(this.dataTypes[this.dataType]) == 'undefined') {
			this.form.changed	= true;
			return true;
		}
		
		fct_check = (this.dataTypes[this.dataType]);
		eval('res = ' + fct_check + '("' + this.value() + '");');
		if (!res) {
			if (typeof(this.dataTypeMsg) != 'undefined' && this.dataTypeMsg != '') {
				msg = this.dataTypeMsg;
			} else {
				msg = this.form.translations['fr']['data-type'];
			}
			msg = msg.replace(/%s/, this.label);
			msg = msg.replace(/%s/, this.form.translations['fr']['type-' + this.dataType]);
			this.errorMsg += msg;
			if (display_msg == true) {				
				alert(msg);
			}
		}
		
		if (res) {
			$(this.labelObject).removeClass('error');
			return true;
		} else {
			$(this.labelObject).addClass('error');
			return  false;
		}
		
		if (VALIDATOR_DEBUG) {
 			alert('succès de de la validation : "' + this.name + '"');
		}
		return res;
	}
	
	function Field_validate(display_errors){
		this.errorMsg 	= '';
		value			= this.value();
		if (VALIDATOR_DEBUG) {
			alert('valide : ' + this.name + ' requis ' + this.required + ' valeur : "' + value + '" (' + typeof(value) + ') type ' + this.dataType);
		}
		if (this.required) {
			if (VALIDATOR_DEBUG) {
 				alert('champ : "' + this.name + '" obligatoire');
			}
			if (value == null) {
				//alert(this.form.translations['fr']['required'].replace(/%s/, this.label));
				this.errorMsg += this.form.translations['fr']['required'].replace(/%s/, this.label.replace(/\s*:\s*$/, '').replace(/^\s/, ''));
			}
		}
		
		if (value != null && !this.checkType(display_errors)) {;}
		
		if (VALIDATOR_DEBUG) {
 			alert('champ : "' + this.name + '" message d\'erreur : ' + this.errorMsg);
		}
		
		if (this.errorMsg == '' ) {
			$(this.labelObject).removeClass('error');
			return true;
		} else {
			$(this.labelObject).addClass('error');
			return  false;
		}
	}

	function Field_getCurrentValue(){
		switch (this.controleType) {
			case "text" :
			case "file" :
			case "textarea" :
			case "password" :
				value = (document.getElementsByName(this.name)[0].value == '' ? null : document.getElementsByName(this.name)[0].value);
				if (value != null) {
					value	= value.replace(/^\s*/, '').replace(/\s*$/, '');
					document.getElementsByName(this.name)[0].value	= value;
				}
				return value;
			break;
			case "select" :
				/* une valeur égale à 0 ou une chaine vide sont interprétées comme si l'utilisateur n'avait sélectionné aucune valeur */
				lst = document.getElementsByName(this.name)[0];
				valeur = lst[lst.selectedIndex].value;
				//alert(valeur);
				return (valeur == '' || valeur == "0" || valeur == null) ? null : valeur;
			break;
			case "radio" :
				/* une valeur égale à 0 ou une chaine vide sont interprétées comme si l'utilisateur n'avait sélectionné aucune valeur */
				ctrls	= lst = document.getElementsByName(this.name);
				nb		= ctrls.length;				
				for (i = 0; i < nb && !ctrls[i].checked; i++) {;}
				return i < nb ? ctrls[i].value : null;
			break;
			case "checkbox" :
				/* une valeur égale à 0 ou une chaine vide sont interprétées comme si l'utilisateur n'avait sélectionné aucune valeur */
				if (document.getElementsByName(this.name).length != 0) {
					return document.getElementsByName(this.name)[0].checked ? document.getElementsByName(this.name)[0].value : null;
				}
			break;
			default :
				alert("Type de controle inconnu,\nimpossible de déterminer la valeur." + this.type + this.name);
			break;
		}
	}

	function Field_toString() {
		var str = "";
		str += "FormName : " + this.FormName + "\n";
		str += "Name : " + this.Name + "\n";
		str += "Type : " + this.Type + "\n";
		str += "Required : " + this.Required + "\n";
		str += "RequiredDataType : " + this.RequiredDataType + "\n";
		str += "DataTypeErrMsg : " + this.DataTypeErrMsg + "\n";
		str += "Index : " + this.Index + "\n";
		str += "Designation : " + this.Designation + "\n";
		return str;
	}


// --------------------------------------------------------------------------- #
//                     fonction de controle des saisies                        #
// --------------------------------------------------------------------------- #
	/* vérifie que la chaine passée en paramètre es bien un cp de france métropol */
	function field_check_zipcode(cp){
		return (!isNaN(parseInt(cp.replace(/^0*/, ''))) && parseInt(cp.replace(/^0*/, '')) > 0 && cp.toString().length == 5);
	}

	function field_check_integer(Chaine){
		// vérifie que la chaine passée en param contient uniquement des entiers
		if(Chaine.match(/^[ ]*[+-]?\d+[ ]*$/)) {
			return true;
		} else {
			return false;
		}
	}

	function field_check_decimal(Chaine){
		return (Chaine.match(/^[0-9\.,]+$/) != null);
	}
   
	function field_check_email(Chaine){
		/* expression extraite de http://atranchant.developpez.com/code/validation/index.php 
		respecte les RFC 2822 et 1035
		http://www.faqs.org/rfcs/rfc2822.html */
		//if ()
		if (typeof(Chaine) != 'string') {
			return false;			
		}
		Chaine	= Chaine.replace(/(^\s|\s$)/, '');
		regex 	= '^[-a-z0-9!#$%&\'*+\/=?^_`{|}~\.]+@([a-z0-9\-]{1,63}\\.)+([a-z0-9]{2,63})$';	
		reg		= new RegExp(regex, 'i');
		return (reg.exec(Chaine) != null);
	
		//return (typeof(Chaine) != 'undefined' && Chaine != null && Chaine != '' && Chaine.match(//))
	}

	function field_check_date(Chaine){
		Chaine	= Chaine.replace(/(^\s|\s$)/, '');	
		if (typeof(Chaine) != 'string' || Chaine == null || Chaine == '' || !Chaine.match(/[0-9]{2}\/[0-9]{2}\/[0-9]{4}/)) {
			return false
		}
		/* vérifie que la date a l'air cohérente */
		var tab_date = new Array();
		tab_date		= Chaine.split('/');
				
		if (isNaN(parseFloat(tab_date[0])) || parseFloat(tab_date[0]) > 31 || isNaN(parseFloat(tab_date[1])) || parseFloat(tab_date[1]) > 12 || isNaN(parseFloat(tab_date[2])) || tab_date[2] > 2100) {			
			return false;
		} else {
			return true;
		}
	}
	
	/* contrôle la validité d'un numéro de téléphone (10 à 13 chiffres - total != 0) */
	function field_check_telnum(tel_num){
		//alert('check '+ tel_num);
		tel_num = tel_num.replace(/\s/g,'');
		return (tel_num.match(/^[0-9]{10,13}$/) != null && !isNaN(parseInt(tel_num.replace(/^0*/, ''))) && parseInt(tel_num.replace(/^0*/, '')) > 0 && tel_num.toString().length >= 10 && tel_num.toString().length < 14);
	}
	
	/* formatage */
	
	function field_format_upper(str){
		//alert('"' + str + '"' + typeof(str) + (str == '') + str.toUpperCase());
		return (str == '' ? '' : str.toUpperCase());
	}
	
	function field_format_lower(str){
		return (str == '' ? '' : str.toLowerCase());
	}
	
	/** 
	* met en majuscule :
	* - la première lettre de la chaîne
	* - la deuxième lettre de chaque mot si un paramètre true est reçu en 2e position 
	*/
	function field_format_ucfirst(str){
		if (arguments.length > 1 && arguments[1]) {
			arr_words = str.split(/ /);
		} else {
			arr_words = new Array(str);
		}
		
		nb = arr_words.length;
		str = '';
		for (i = 0; i < nb; i++) {
			str += arr_words[i].charAt(0).toUpperCase() + arr_words[i].substring(1);
			if (i < nb - 1) {
				str += ' ';
			}
		}
		return str;
	}
	
	function field_format_ucwords(str){
		return field_format_ucfirst(str, true);
	}

	function field_format_telnum(tel_num){
		tel_num = tel_num.replace(/\s/g,'');
		return tel_num.replace(/(([0-9][^0-9]*){2})/g, "$1 ");
	}

// ------------------- INTERCEPTION DES EVENEMENTS FORMULAIRE ------------------
	function formCheckChange(obj){
		return obj.changed();
	}

	//function formValidate(obj){
	//	alert('ici');
	//	return obj.validate();
	//}