//EXEMPLE D'APPEL de la classe

//var formulaire = new controleurFormulaire('frm_authentification','frm_authentification');
//formulaire.ajouterElement(new Array('c_auth_login',1,'mail','Votre identifiant est incorrect','Input_normal','ipt_error'),'formulaire');
//formulaire.ajouterElement(new Array('c_auth_pwd',1,'alphanum','Votre mot de passe doit être renseigné','Input_normal','ipt_error'),'formulaire');




//Constructeur de la classe controleurFormulaire
function controleurFormulaire(formID,formName)
{
	/////////////////////
	//	Paramètres
	/////////////////////
	this.id = formID;
	this.name = formName;
	this.parametres = new Array();
	this.indicesParam = new Array();
	this.erreurs = new Array();
	///////////////////
	//	Méthodes
	///////////////////
		//Ajouter une nouvelle ligne de paramètres concernant un Input dans le tableau this.parametres
	this.ajouterInput = ajouterInput;
		//Ajouter un évènement à un élément du formulaire
	this.ajouterEvenementOnchange = ajouterEvenementOnchange;
		//Modifier la priorité d'un champ du formulaire
	this.changePriorite = changePriorite;
		//Appel vers la fonction traitant le formulaire et effectuant un changement de classes CSS sur les éléments en erreur
	this.traiteErreurs = traiteErreurs;
		//Appel vers la fonction traitant un champ bien particulier du formulaire
	this.analyseInputErreur = analyseInputErreur;
		//Appel vers la fonction controleForm basique
	this.controleForm = ControleForm;
		//Appel vers la fonction renvoyant les ID de tous les champs "mal" ou "pas" renseignés
	this.controleFormTableau = ControleFormTableau;
	
	this.ajouterElement = ajouterElement ;

}

/****************************************************************************************************************/
/***************************************************************************************************************/
/**************************************** 	LES METHODES	***************************************************/
/*************************************************************************************************************/
/************************************************************************************************************/

//Rajoute une nouvelle ligne de paramètres concernant un élément du formulaire dans this.paramètres
function ajouterInput(inputArray)
{	this.parametres[this.parametres.length] = inputArray;
	this.indicesParam[inputArray[0]] = this.parametres.length-1;
}


function ajouterEvenementOnchange(elt_id,nomobjet)
{	var elt = document.getElementById(elt_id);
	if (!elt) {
		 return;
	}
	eval("elt.onchange = function () { "+nomobjet+".analyseInputErreur(this); } ;");
}

function evenementOnchange()
{	formulaire.analyseInputErreur(this);
}

function ajouterElement(inputArray,nomobjet)
{	this.ajouterInput(inputArray) ;
	this.ajouterEvenementOnchange(inputArray[0],nomobjet) ;
}

//Fonction rendant obligatoire ou non un élément de l'objet formulaire
function changePriorite(elementId,priorite)
{	if(priorite==0)
		this.parametres[this.indicesParam[elementId]][1]=0;
	else
		this.parametres[this.indicesParam[elementId]][1]=1;
}

//Fonction traitant le tableau d'erreurs renvoyé par controleFormTableau
//Elle effectue notamment un changement de classes pour les champs en erreur
function traiteErreurs()
{	
	this.erreurs = ControleFormTableau(this.parametres);
	var firstErreur = "";
	if (this.erreurs.length!=0)
	{	//application de la classe classeErreur pour tous les champs en erreur 
		for(var i=0;i<this.erreurs.length;i++)
		{	var objet = window.document.getElementById(this.erreurs[i][0]);
			objet.className = this.erreurs[i][5];
			if(i==0) {
			 firstErreur=this.erreurs[i][0];
			 var msg = this.erreurs[i][3];
			}
		}
		if(firstErreur!="")
		{	
			alert(msg);
			window.location.href = "#"+firstErreur;
		}
		return false;
	}
	else
		return true;
}

//Analyse un champ bien particulier via le tableau this.parametres
function analyseInputErreur(champ)
{	//Recherche de la ligne du tableau correspondant au champ
	for(var i=0;i<this.parametres.length;i++)
	{	if(this.parametres[i][0]==champ.id)
		{	var ConfigChamp = new Array(this.parametres[i]);
			this.erreurs = ControleFormTableau(ConfigChamp);
			if(this.erreurs.length>0)
			{	//le champ analyse est en erreur
				champ.className = ConfigChamp[0][5];
			}
			else
			{	champ.className = ConfigChamp[0][4];
			}
		}//Recuperation de la ligne du tableau correspondant au champ en cours d'analyse
	}//Fin du FOR de recherche dans le tableau de configuration
}

//Fonction généraliste de controle de formulaire 
//cette fonction est à étoffer en fonction des différents RegExp qui sont déjà dans ce fichier
function ControleForm(tableau,classeErreur)
{	//teste les types : alpha, alphanum, num, tel, mail, date
	var i;	
	for(i=0;i<tableau.length;i++)
	{   var elt_form=document.getElementById(tableau[i][0]);
	   
		//test sur le caractéres obligatoire de l'élément du formulaire
		if( tableau[i][1]==1 )
		{	if (elt_form.value =="")
			{	elt_form.focus();
				alert(tableau[i][3]+'\nCe champ est un champ obligatoire');
				return false;
			}
		}
		
		
		switch(tableau[i][2])
		{	case 'alpha':
				if(isNotAlphabetic(elt_form.value))
				{	alert(tableau[i][3]+'\nIl doit être au format Alphabétique');
					elt_form.focus();
					return false;
				}
			break;
			case 'alphanum':
				if(isNotAlphanumeric(elt_form.value))
				{	alert(tableau[i][3]+'\nIl doit être au format Alphanumérique');
					elt_form.focus();
					return false;
				}
			break;
			case 'num':
				if(isNotNumeric(elt_form.value))
				{	alert(tableau[i][3]);
					elt_form.focus();
					return false;
				}
			break;
			case 'telfixe':
				if(isNotTelephone(elt_form.value,'fixe'))
				{	alert(tableau[i][3]+'\nLe numéro de téléphone fixe doit comporter 10 chiffres\net doit commencer par 01, 02, 03, 04, 05 ou 08\nle séparateur doit être des espaces, ou des tirets ou des points');
					elt_form.focus();
					return false;
				}
			break;
			case 'telnational':
				if(isNotTelephone(elt_form.value,'nati'))
				{	alert(tableau[i][3]+'\nLe numéro de téléphone national doit comporter 10 chiffres\net doit commencer par 01, 02, 03, 04, 05, 06 ou 08\nle séparateur doit être des espaces, ou des tirets ou des points');
					elt_form.focus();
					return false;
				}
			break;
			case 'telport':
				if(isNotTelephone(elt_form.value,'port'))
				{	alert(tableau[i][3]+'\nLe numéro de téléphone portable doit comporter\n10 chiffres + des espaces ou - ou .\net doit commencer par 06');
					elt_form.focus();
					return false;
				}
			break;
			case 'mail':
				if(!isEmail(elt_form.value)==false)
				{	alert(tableau[i][3]);
					elt_form.focus();
					return false;
				}
			break;	
			case 'date':
				if(!Teste_date(elt_form))
				{
				  elt_form.focus();
					return false; //pas de message d'erreur a ce niveau 
					//c'est directement les fonctions Teste_date , Is_Date_valide qui s'en charge ...
					// permet d'avoir un message un peu plus précis
				}
			break;	
			 case 'cp':
				if(isNotCodePostal(elt_form.value))
				{	alert(tableau[i][3]+"\nIl doit faire 5 caractéres numériques");
					elt_form.focus();
					return false;
				}
			break;	
		}
   }
   return true;
}


//retourne un tableau contenant les identifiants de tout les champs étant en erreur
function ControleFormTableau(tableau)
{	//teste les types : alpha, alphanum, num, tel, mail, date
	tab_erreurs = new Array();
	var champ_erreur="";
  
	for(var i=0;i<tableau.length;i++)
	{	
	var elt_form=document.getElementById(tableau[i][0]);
	  //test sur le caractère obligatoire de l'élément du formulaire
		if( tableau[i][1]==1 )
		{	if (tableau[i][2]!="liste" && elt_form.value =="")
			{	champ_erreur = tableau[i];
			}
			else 
			{
			  if(tableau[i][2]=="liste" && elt_form.selectedIndex==0)
  			{	champ_erreur = tableau[i];
  			}
			}
		}
		
		if(elt_form.value!="")
		{	switch(tableau[i][2])
			{	case 'alpha':
					if(isNotAlphabetic(elt_form.value))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'alphanum':
					if(isNotAlphanumeric(elt_form.value))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'num':
					if(isNotNumeric(elt_form.value))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'telfixe':
					if(isNotTelephone(elt_form.value,'fixe'))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'telnational':
					if(isNotTelephone(elt_form.value,'nati'))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'telport':
					if(isNotTelephone(elt_form.value,'port'))
					{	champ_erreur = tableau[i];
					}
				break;
				case 'mail':
					if(!isEmail(elt_form.value)==false)
					{	champ_erreur = tableau[i];
					}
				break;	
				case 'date':
					if(!Teste_date(elt_form))
					{	champ_erreur = tableau[i];
					}	
				break;	
				 case 'cp':
					if(isNotCodePostal(elt_form.value))
					{	champ_erreur = tableau[i];
					}
				break;	
				 case 'liste':	//Input de type "SELECT"
					if(elt_form.selectedIndex==0)
					{	//Un élément minimum doit être sélectionné en dehors de la première option 
						champ_erreur = tableau[i];
					}
				break;	
			}
		}
		if(champ_erreur!="")
		{	tab_erreurs[tab_erreurs.length] = champ_erreur;
			champ_erreur="";
		}
	}	//ENDFOR : boucle sur chaque ligne du tableau de parametres du formulaire
	return tab_erreurs;
}




/****************************************************************************************************************/
/***************************************************************************************************************/
/*****************************		CONTROLE DES TYPES DE DONNEES		***************************************/
/*************************************************************************************************************/
/************************************************************************************************************/


/************************************************
***				Type Alpha					*****
************************************************/

function IsNotAlpha(chaine)
{	expr_reg=new RegExp("[A-Za-z]+");
	return expr_reg.test(chaine);
}


/************************************************
***				Type AlphaNum					*****
************************************************/

function IsNotAlphaNum(chaine)
{	expr_reg=new RegExp("[A-Za-z0-9]+");
	return expr_reg.test(chaine);
}


/************************************************
***				Type Date					*****
************************************************/

function Teste_date(objName)
{	var datefield = objName;
	if (is_date_valide(objName) == false)
	{	datefield.select();
		alert("Date incorrecte format (jj/mm/aa).  Merci de vérifier votre saisie.");
		datefield.focus();
		return false;
	}
	else
	{	return true;
	}
}

function is_date_valide(objName)
{	//var strDatestyle = "US"; //United States date style
	var strDatestyle = "EU";  //European date style
	var strDate;
	var strDateArray;
	var strDay ="";
	var strMonth ="";
	var strYear="";
	var intday;
	var intMonth;
	var intYear;
	var booFound = false;
	var datefield = objName;
	var strSeparatorArray = new Array("-"," ","/",".","_");
	var intElementNr;
	var err = 0;
	var strMonthArray = new Array(12);
	strMonthArray[0] = "01";
	strMonthArray[1] = "02";
	strMonthArray[2] = "03";
	strMonthArray[3] = "04";
	strMonthArray[4] = "05";
	strMonthArray[5] = "06";
	strMonthArray[6] = "07";
	strMonthArray[7] = "08";
	strMonthArray[8] = "09";
	strMonthArray[9] = "10";
	strMonthArray[10] = "11";
	strMonthArray[11] = "12";
	strDate = datefield.value;
	if (strDate.length < 1)
	{	return true;
	}
	
	for (intElementNr = 0; intElementNr < strSeparatorArray.length; intElementNr++) 
	{	if (strDate.indexOf(strSeparatorArray[intElementNr]) != -1) 
		{	strDateArray = strDate.split(strSeparatorArray[intElementNr]);
			if (strDateArray.length != 3) 
			{	err = 1;
				return false;
			}
			else
			{	strDay = strDateArray[0];
				strMonth = strDateArray[1];
				strYear = strDateArray[2];
			}
			booFound = true;
		}
	}
	
	if (booFound == false)
	{	if (strDate.length>5)
		{	strDay = strDate.substr(0, 2);
			strMonth = strDate.substr(2, 2);
			strYear = strDate.substr(4);
		}
	}

	//on ne peut pas dire que l'on est en 2000 ou en 1900 ...
	//vu que l'on va utiliser cette fonction pour différents types de date
	//if (strYear.length == 2) {
	//strYear = '20' + strYear;
	//}
	
	
	// US style
	//if (strDatestyle == "US") {
	//strTemp = strDay;
	//strDay = strMonth;
	//strMonth = strTemp;
	//}

	intday = parseInt(strDay, 10);
	if (isNaN(intday))
	{	err = 2;
		return false;
	}
	intMonth = parseInt(strMonth, 10);
	if (isNaN(intMonth))
	{	for (i = 0;i<12;i++)
		{	if (strMonth.toUpperCase() == strMonthArray[i].toUpperCase())
			{	intMonth = i+1;
				strMonth = strMonthArray[i];
				i = 12;
			}
		}
		if (isNaN(intMonth))
		{	err = 3;
			return false;
		}
	}
	intYear = parseInt(strYear, 10);
	if (isNaN(intYear))
	{	err = 4;
		return false;
	}
	
	if (intMonth>12 || intMonth<1)
	{	err = 5;
		return false;
	}
	
	if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intday > 31 || intday < 1))
	{	err = 6;
		return false;
	}
	
	if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intday > 30 || intday < 1))
	{	err = 7;
		return false;
	}
	
	if (intMonth == 2)
	{	if (intday < 1)
		{	err = 8;
			return false;
		}
		if (Is_Bisextile(intYear) == true)
		{	if (intday > 29)
			{	err = 9;
				return false;
			}
		}
		else
		{	if (intday > 28)
			{	err = 10;
				return false;
			}
		}
	}
	
	if (strDatestyle == "US")
	{	datefield.value = strMonthArray[intMonth-1] + " " + intday+" " + strYear;
	}
	else
	{	if (intday < 10)
			intday = "0" + intday;
		datefield.value = intday + "/" + strMonthArray[intMonth-1] + "/" + strYear;
	}
	return true;
}



function Is_Bisextile(intYear)
{
	if (intYear % 100 == 0)
	{	if (intYear % 400 == 0)
			return true;
	}
	else 
	{	if ((intYear % 4) == 0)
			return true;
	}
	return false;
}


// Expressions régulières de test de longueur
var regExpEmpty="^$";					// Accepte une chaine vide
var regExp8Chars="^[0-9a-zA-Z]{8,}$";			// Accepte une chaine d'au moins 8 carctères alphanumeriques (pour un mot de passe par exemple).

// Expressions régulières de test de type de caractère
//var regExpAlphanumeric="[0-9a-zA-Z]+";			// Accepte une chaine alphanumérique
var regExpAlphanumeric="([0-9a-zA-Z])*";			// Accepte une chaine alphanumérique ou rien
var regExpAlphanumericWithWhitespace="^[0-9a-zA-Z ]+$";			// Accepte une chaine alphanumérique + ' '
var regExpAlphabetic="^[a-zA-Z'_\\-àäâéèëêîîïöôùüûç\/ ]+$";		// 'Accepte une chaine alphabétique
var regExpAlphabeticAvecEspaceEtMoins="^[a-zA-Z -]+$";		// Accepte une chaine alphabétique + ' ' + '-'/
var regExpNumeric="[0-9]+";				// Accepte une chaine numérique

// Expressions régulières de test de type
var regExpInt="^[0-9]+$";				// Accepte une chaine de type 'int'

var regExpDouble="^[-+]?[0-9]+(\.[0-9]+)?$";		// Accepte une chaine de type 'double'
var regExpFloat="^[-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?$";	// Accepte une chaine de type 'float'
var regExpTime="^([01][0-9]|2[0123])\:([012345][0-9])(\:([012345][0-9])(.([0-9]{3})+)?)?$";		 // Accepte une chaine de type 'time'. Ex : 12:51 ou 21:45:35.654
var regExpFrenchDate="^(0[1-9]|[12][0-9]|3[01])[\- \/\.](0[1-9]|1[012])[\- \/\.](19|20)\d\d$";  // date au format jj/mm/aaaa ou jj-mm-aaaa ou jj mm aaaa ou jj.mm.aaaa avec aaaa compris entre 1900 et 2099.
var regExpEnglishDate="^(19|20)\d\d[\- \/\.](0[1-9]|1[012])[\- \/\.](0[1-9]|[12][0-9]|3[01])$"; // idem ci-dessus mais format anglais (Ex : aaaa/mm/jj)
var regExpBoolean="^true|false$";			// Accepte une chaine de type 'boolean'

// Expressions régulières de test de types administratifs français
//var regExpCodePostal="^([A-Z]+[A-Z]?\-)?[0-9]{1,2} ?[0-9]{3}+$";							// Accepte une chaine de type 'code postal'. Ex : F-33370 ou 33 370 ou 33370 ou F-1 370
var regExpCodePostal="^[0-9]{5}$";

var regExpTelephoneFixe="^(01|02|03|04|05|08)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";		// Accepte un numero de téléphone de type 'fixe'. Ex : 01.34.12.52.30 ou 0134125230
var regExpTelephonePortable="^(06)[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";			// Accepte un numero de téléphone de type 'portable'.
var regExpTelephoneNational="^(0[1234568])[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";		// Accepte un numero de téléphone de type 'national' y compris numéros en '08'.
var regExpTelephoneInternational="^(\+[0-9]{2})[ \.\-]?[0-9][ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{2}$";	// Accepte un numero de téléphone de type 'international'. Ex : (+33) 1 34 12 52 30

var regExpNumeroSecuriteSociale="^[12][ \.\-]?[0-9]{2}[ \.\-]?(0[1-9]|[1][0-2])[ \.\-]?([0-9]{2}|2A|2B)[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{2}$"; // Accepte un numero de sécurité sociale français. Ex : 1 85 34 33 354 450 45

var regExpTVAIntracommunautaire="^[A-Z]{2}[ \.\-]?[0-9]{2}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";		// Accepte un numero de TVA Intra-communautaire. Ex : FR 02 254 254 254
var regExpNumeroSiren="^[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}$";							// Accepte un numero SIREN. Ex : 254 254 254
var regExpNumeroSiret="^[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{3}[ \.\-]?[0-9]{5}$";					// Accepte un numero SIRET. Ex : 254 254 254 12345
var regExpCodeApe="^[0-9]{2}[ \.\-]?[0-9]{1} ?[a-zA-Z]$";								// Accepte un code APE. Ex : 25.4Z

// Expressions régulières de test de types liés à internet

//var regExpEmailAdress="^[\w\-\.]*@[\w\-\.]*\.[a-zA-Z]{2,3}$";

//var regExpEmailAdress="^[A-Za-z0-9]+(([_\.\-]{1}[a-zA-Z0-9]+)*)@([A-Za-z0-9_\-]+)(\.([A-Za-z]{2,3})){1}$";										// Accepte une adresse email. Ex : toto@toto.com
var regExpEmailAdress="^[\\w\\-]+(\\.[\\w\\-]+)*@[\\w\\-]+(\\.[\\w\\-]+)*\\.[\\w\\-]{2,}$";										// Accepte une adresse email. Ex : toto@toto.com
var regExpIpAdress="\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b";	// Accepte une adresse ip. Ex : 192.168.0.1
var regExpDomainName="^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}$";													// Accepte un nom de domaine. Ex : toto.com
var regExpUrl="^(((ht|f)tp(s?))\:\/\/)?(([a-zA-Z0-9]+([@\-\.]?[a-zA-Z0-9]+)*)(\:[a-zA-Z0-9\-\.]+)?@)?(www.|ftp.|[a-zA-Z]+.)?[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,})(\:[0-9]+)?\/?";			// Accepte une url ftp, http ou https, avec ou sans login/mot de passe, avec ou sans numero de port. Ex : http://www.toto.com, ftp://toto:toto@ftp.toto.com:21/

var regExpHexColor="^#[0-9A-Fa-f]{6}$"; // Accepte une couleur hexadécimale

//Les deux fonction suivantes servent à identifier si une chaine de caractère est compatible ou non avec une expression régulière passée en paramètre
function matchRegularExpression(valeur, regularExpression)
{	//var resultat = valeur.match(regularExpression,"g");
	var regExpression=new RegExp(regularExpression, "g");
	var resultat = regExpression.test(valeur);
	//alert(valeur+'\n'+resultat);
	if(resultat==null || resultat==false)
		return false;
	else
		return true;
}

function doesntMatchRegularExpression(valeur, regularExpression)
{	if(matchRegularExpression(valeur, regularExpression))
		return false;
	else
		return true;
}

/*
les fonctions de contrôle suivantes prennent toutes comme argument la valeur de l'attribut "value" d'un champ de formulaire de type "text", "textarea" ou "password"
*/
function isEmpty(valeur)
{	return matchRegularExpression(valeur, regExpEmpty);
}

function isNotEmpty(valeur)
{	return doesntMatchRegularExpression(valeur, regExpEmpty);
}

function isNot8CharsLength(valeur)
{	return doesntMatchRegularExpression(valeur, regExp8Chars);
}

function isNotAlphanumeric(valeur)
{	return doesntMatchRegularExpression(valeur, regExpAlphanumeric);
}

function isNotAlphanumericWithWhitespace(valeur)
{	return doesntMatchRegularExpression(valeur, regExpAlphanumericWithWhitespace);
}

function isNotAlphabeticAvecEspaceEtMoins(valeur)
{	return doesntMatchRegularExpression(valeur, regExpAlphabeticAvecEspaceEtMoins);
}

function isNotAlphabetic(valeur)
{	return doesntMatchRegularExpression(valeur, regExpAlphabetic);
}

function isNotNumeric(valeur)
{	return doesntMatchRegularExpression(valeur, regExpNumeric);
}

function isNotInt(valeur)
{	return doesntMatchRegularExpression(valeur, regExpInt);
}

function isNotDouble(valeur)
{	return doesntMatchRegularExpression(valeur, regExpDouble);
}

function isNotFloat(valeur)
{	return doesntMatchRegularExpression(valeur, regExpInt);
}

function isNotBoolean(valeur)
{	return doesntMatchRegularExpression(valeur, regExpBoolean);
}

function isNotTime(valeur)
{	return doesntMatchRegularExpression(valeur, regExpTime);
}
/*
function isNotDate(valeur, mode)
{
	switch (mode)
	{
		case "fr" : 
			return doesntMatchRegularExpression(valeur, regExpFrenchDate);
			break;
		case "en" :
			return doesntMatchRegularExpression(valeur, regExpEnglishDate);
			break;
		default : 
			return doesntMatchRegularExpression(valeur, regExpFrenchDate);
			break;
	}
}*/

function isNotCodePostal(valeur)
{	return doesntMatchRegularExpression(valeur, regExpCodePostal);
}

function isNotTelephone(valeur, mode)
{
	switch (mode)
	{	case "fixe" : 
			return doesntMatchRegularExpression(valeur, regExpTelephoneFixe);
			break;
		case "port" :
			return doesntMatchRegularExpression(valeur, regExpTelephonePortable);
			break;
		case "nati" :
			return doesntMatchRegularExpression(valeur, regExpTelephoneNational);
			break;
		case "inte" :
			return doesntMatchRegularExpression(valeur, regExpTelephoneInternational);
			break;
		default : 
			return doesntMatchRegularExpression(valeur, regExpTelephoneNational);
			break;
	}
	return false;
}

function isNotNumeroSecuriteSociale(valeur)
{	return doesntMatchRegularExpression(valeur, regExpNumeroSecuriteSociale);
}

function isNotTVAIntracommunautaire(valeur)
{	return doesntMatchRegularExpression(valeur, regExpTVAIntracommunautaire);
}

function isNotNumeroSiren(valeur)
{	return doesntMatchRegularExpression(valeur, regExpNumeroSiren);
}

function isNotNumeroSiret(valeur)
{	return doesntMatchRegularExpression(valeur, regExpNumeroSiret);
}

function isNotCodeApe(valeur)
{	return doesntMatchRegularExpression(valeur, regExpCodeApe);
}

function isEmail(valeur)
{	return doesntMatchRegularExpression(valeur, regExpEmailAdress);
}

function isNotIpAdress(valeur)
{	return doesntMatchRegularExpression(valeur, regExpIpAdress);
}

function isNotDomainName(valeur)
{	return doesntMatchRegularExpression(valeur, regExpDomainName);
}

function isNotUrl(valeur)
{	return doesntMatchRegularExpression(valeur, regExpUrl);
}

function isNotHexColor(valeur)
{	return doesntMatchRegularExpression(valeur, regExpHexColor);
}