//$=========================================================================================
//$=========================================================================================
//$ Déclaration des variables globales
//$=========================================================================================
//$ Définition des caratères numériques
GEN_NumChars = "0123456789";

//$ Séparateur d'email
GEN_MailSep = ",";

//$ Définition des caratères alphanumeriques
GEN_CharChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

//$ Définition des caratères pouvant être utilisé dans les type "DATE"
GEN_CharDate = "DMY";

//$ Définition des mauvais caratères pouvant être trouvés dans un e-mail
GEN_BadMail = "/;:<>*|'&$!§#(){}` ";

//$ Détermine si l'on affiche ou non les erreurs par champs
GEN_ShowFieldError = false;

//$ Tableau des groupes de champs
var GEN_GroupField = new Array();

//$ Tableau des champs pour le groupe
var GEN_FieldGroup = new Array();

//$ Tableau de type de test pour chaque champ
var GEN_TypeFieldTest = new Array();

//$ Tableau des champs à tester
var GEN_FieldTest = new Array();

//$ Texte des erreur propre aux champs
var GEN_FieldTextError = new Array();

//$ Tableau des erreurs
var GEN_TblError = new Array();

//$ Tableau d'information de l'affichage des erreurs
var GEN_TblShowErrorConfig = new Array();
GEN_TblShowErrorConfig['Text'] = "";
GEN_TblShowErrorConfig['Type'] = "";
GEN_TblShowErrorConfig['Config'] = "";
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui créé les groupes
//$=========================================================================================
function ContentInGroup()
{
	//$ Récupération des arguments
	var TblArgument = ContentInGroup.arguments;

	//$ Déclaration des variables locales	
	var FieldName = "";
	var GroupName = "";
	var Index;
	
	//$ Initialisation du nom du groupe
	GroupName = TblArgument[0];
	
	//$ Initialisation du tableau des groupes
	for(Index = 1; Index < TblArgument.length; Index++)
	{
		if(FieldName == "")
		{
			FieldName = TblArgument[Index];
		}
		else
		{
			FieldName = FieldName + ";" + TblArgument[Index];
		}
		
		//$ Ecriture du groupe associé au champs
		eval("GEN_FieldGroup['" + TblArgument[Index] + "'] = '" + GroupName + "'");
	}
	
	//$ Ajout dans le tableau
	eval("GEN_GroupField['" + GroupName + "'] = '" + FieldName + "'");
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui teste les champs
//$=========================================================================================
function FieldTest() 
{
	//$ Récupération des arguments
	var TblArgument = FieldTest.arguments;
	
	//$ Déclaration des variables locales
	var FieldName = "";
	var Index;
	var Test = "";
	var TypeTest;
	var ExpReg;
	
	//$ Retirer les espaces	
	TblArgument = RetireEspace(TblArgument);

	//$ Initialisation du nom du groupe
	FieldName = TblArgument[0];
	
	//$ Initialisation du tableau des groupes
	for(Index = 1; Index < TblArgument.length; Index++)
	{
		//$ Initialisation du type de tests
		TypeTest = TblArgument[Index];
		
		//$ Mettre en majuscule sauf lors de la comparaison pour éviter de convertir le nom des champs de formulaire 
		//$ ou du format pour éviter les problème d'expression régulière
		ExpReg = new RegExp("IDEM", ["i"]);
		if(ExpReg.test(TypeTest))
		{
			TypeTest = TypeTest.replace(/^IDEM/i, "IDEM");
		}		
		else
		{	
			ExpReg = new RegExp("FORMAT", ["i"]);
			if(ExpReg.test(TypeTest))
			{
				TypeTest = TypeTest.replace(/^FORMAT/i, "FORMAT");
				TypeTest = TypeTest.replace(/\\/gi, "\\\\");
			}	
			else
			{
				//$ Mettre en majuscule
				TypeTest = TypeTest.toUpperCase();
			}
		}
		
		if(Test == "")
		{
			Test = TypeTest;
		}
		else
		{
			Test = Test + ";" + TypeTest;		
		}
	}
	
	//$ Ajout des tests dans le tableau dans le tableau des types de tests
	eval("GEN_TypeFieldTest['" + FieldName + "'] = '" + Test + "'");
	
	//$ Ajout dans le tableau des champs à tester
	GEN_FieldTest[GEN_FieldTest.length] = FieldName;
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui indique les erreurs à afficher pour chaque champ
//$=========================================================================================
function ConfigShowError()
{
	//$ Récupération des arguments
	var TblArgument = ConfigShowError.arguments;
	
	//$ Initialisation des informations pour l'affichage de l'erreur
	GEN_TblShowErrorConfig['Text'] = TblArgument[0];
	GEN_TblShowErrorConfig['Type'] = TblArgument[1];	
	
	if(TblArgument.length > 2)
	{
		GEN_TblShowErrorConfig['Config'] = TblArgument[2];
	}
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui indique les erreurs à afficher pour chaque champ
//$=========================================================================================
function FieldTextError(FieldName, TextError)
{
	//$ Initialisation du tableau des textes d'erreur
	eval("GEN_FieldTextError['" + FieldName + "'] = \"" + TextError + "\"");

	//$ Indique que l'on veut voir apparaître les erreurs propre à chaque champ
	GEN_ShowFieldError = true;
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie le formulaire
//$=========================================================================================
function Verif_Formulaire(Form)
{
	//$ Declaration des variables locales
	var NoError = true;
	var MsgError = "";
	var IndexField;
	var ReturnError;
	var Element;
	var TblError = new Array();
	var TypeShowError;

	//$ Tester les champs
	for(IndexField = 0; IndexField < GEN_FieldTest.length; IndexField++)
	{
		//$ Initialisation de l'élément courant
		Element = GEN_FieldTest[IndexField];
		
		//$ Initialiser le tableau des erreurs
		eval("TblError['" + Element + "'] = false");
		
		//$ Si l'élément est un groupe
		if(GEN_GroupField[Element])
		{
			ReturnError = TestGroup(Form, Element)
		}
		else
		{
			//$ Tester le champ courant
			ReturnError = TestField(Form, Element);	
		}

		if(ReturnError == true)
		{
			//$ Changement d'etat de NoError
			NoError = false;
			
			if(GEN_FieldTextError[Element])
			{
				MsgError = MsgError + " - " + GEN_FieldTextError[Element] + "\n";			
			}
		}
		
		//$ Si il y a une erreur, on arrête les tests et que l'on ne veut pas voir le détail des erreurs
		if((ReturnError == true) && (GEN_ShowFieldError == false))
		{
			break;
		}
	}

	//$ Affichage du message d'erreur
	if(NoError == false)
	{
		//$ Initialisation du message d'erreur	
		MsgError = GEN_TblShowErrorConfig['Text'] + "\n" + MsgError;		
				
		//$ Affichage
		TypeShowError = GEN_TblShowErrorConfig['Type'];
		TypeShowError = TypeShowError.toUpperCase();
		
		if((TypeShowError == "ALERT") || (TypeShowError == ""))
		{
			alert(MsgError);
		}
		else
		{
			OuvreWindow(GEN_TblShowErrorConfig['Type'], "Error", GEN_TblShowErrorConfig['Config']);
		}
	}

	//$ Renvoi de la variable NoError pour bloquer ou non le submit
	return NoError;	
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui test un champ
//$=========================================================================================
function TestField(Form, Element)
{
	//$ Déclaration des variables locales
	var TblTest = new Array();
	var Index;
	var TypeTest;
	var FormElement = Form.elements[Element];
	var ReturnError = 2;
	
	//$ Si le tableau des tests à effectuer existe pour l'élément
	if(GEN_TypeFieldTest[Element])
	{
		//$ Test à effectuer
		TypeTest = GEN_TypeFieldTest[Element];
		TblTest = TypeTest.split(";");
		
		//$ Tester pour chaque type de test à faire
		for(Index = 0; Index < TblTest.length; Index++)
		{
			//$ Initialisation de l'erreur
			eval("GEN_TblError['" + Element + "'] = false");
			
			//$ Initialisation du type de test
			TypeTest = TblTest[Index];
			
			//$ Effectuer les tests demandés
			ReturnError = Test(FormElement, TypeTest, ReturnError, Form);
			
			//$ Si il y a une erreur, on arrête les tests et que l'on ne veut pas voir le détail des erreurs
			if((ReturnError == true) && (GEN_ShowFieldError == false))
			{
				break;
			}
		}
	}	
	
	//$ Renvoi de l'erreur
	return ReturnError;
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui test un groupe
//$=========================================================================================
function TestGroup(Form, Element)
{
	//$ Déclaration des variables locales
	var TblTest = new Array();
	var TblField = new Array();	
	var IndexTest, IndexField, IndexForm
	var TypeTest, FieldTest;
	var FormElement = Form.elements[Element];
	var ReturnError = 2;
	var TmpField;
	var ExpReg;
			
	//$ Si le tableau des tests à effectuer existe pour l'élément
	if((GEN_TypeFieldTest[Element]) && (GEN_GroupField[Element]))
	{
		//$ Test à effectuer
		TypeTest = GEN_TypeFieldTest[Element];
		TblTest = TypeTest.split(";");
		
		//$ Champ à tester
		FieldTest = GEN_GroupField[Element];
		TblField = FieldTest.split(";");

		FieldTest = "";
		for(IndexField = 0; IndexField < TblField.length; IndexField++)
		{
			if(Form.elements[TblField[IndexField]])
			{
				TmpField = TblField[IndexField];
			}
			else
			{
				//$ Initialisation du champ
				TmpField = "";
				
				// Preparation de l'expression regulière
				ExpReg = new RegExp("^" + TblField[IndexField], ["i"]);				

				for(IndexForm = 0; IndexForm < Form.length; IndexForm++)
				{
					if(ExpReg.test(Form.elements[IndexForm].name))
					{
						if(TmpField == "")
						{
							TmpField = Form.elements[IndexForm].name;
						}
						else
						{
							TmpField = TmpField + ";" + Form.elements[IndexForm].name;
						}						
					}
				}
			}
			
			if(FieldTest == "")
			{
				FieldTest = TmpField;
			}
			else
			{
				FieldTest = FieldTest +";" + TmpField;
			}
		}
		
		//$ Boucler sur les tests à faire
		for(IndexTest = 0; IndexTest < TblTest.length; IndexTest++)
		{
			//$ Initialisation du type de test à faire
			TypeTest = TblTest[IndexTest];
		
			//$ Boucle sur les champs à tester
			TblField = FieldTest.split(";");
			for(IndexField = 0; IndexField < TblField.length; IndexField++)
			{
				//$ Initialisation du champ à tester
				FieldTest = TblField[IndexField];
				FormElement = Form.elements[FieldTest];
				
				//$ Effectuer les tests demandés
				ReturnError = Test(FormElement, TypeTest, ReturnError, Form);
			}
			
			//$ Sortir de la boucle s'il y a une erreur
			if(ReturnError == true)
			{
				break;
			}
		}
	}
	//$ Renvoi de l'erreur
	return ReturnError;
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui test
//$=========================================================================================
function Test(FormElement, TypeTest, CurrentError, Form)
{
	//$ Déclaration des variables locales
	var Erreur = false;
	var Index;
	var ExpReg;
	var Value;
	var TblComparaison = new Array();
	var Comparaison1, Comparaison2;
	var Separateur, Format;
	var TblFormat = new Array();
	var TmpTemp = new Array();
	
	//$ Tests
	switch(TypeTest)
	{
		case "CHECKED":
			if(FormElement.checked == false)
			{
				Erreur = true;
			}			
			break;
		case "NOCHECKED":
			if(FormElement.checked == true)
			{
				Erreur = true;
			}
			break;
		case "SELECTVIDE":
			if(FormElement.length != 0)
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "NOSELECTVIDE":	
			if(FormElement.length == 0)
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "MAIL":
			RetourErreur = VerifMail(FormElement.value)
			if(RetourErreur == 1)
			{
				Erreur = true;
			}		
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;
		case "NOMAIL":
			RetourErreur = VerifMail(FormElement.value)
			if((RetourErreur == 0) && (FormElement.value != ""))
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;		
		case "VIDE":
			if(FormElement.value.length > 0)
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;
		case "NOVIDE":
			if(FormElement.value.length == 0)
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;			
		case "NUM":
			Erreur = VerifNum(FormElement.value);
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "NONUM":
			Erreur = VerifNoNum(FormElement.value);
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;		
		case "CHAR":
			Erreur = VerifChar(FormElement.value);
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "NOCHAR":
			Erreur = VerifNoChar(FormElement.value);
			
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "NUMONLY":
			Erreur = VerifOnlyNum(FormElement.value);
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "CHARONLY":
			Erreur = VerifOnlyChar(FormElement.value);
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;
		case "NUMCHAR":
			Erreur = VerifNumChar(FormElement.value);
			
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;
		case "GPE_CHECKEDONE":
			if(FormElement.checked == true)
			{
				Erreur = false;
			}
			else
			{
				Erreur = true;
			}			
			if(CurrentError < 2)
			{
				Erreur = Erreur & CurrentError;
			}			
			break;	
		case "GPE_NOCHECKED":
			if(FormElement.checked == true)
			{
				Erreur = true;
			}
			else
			{
				Erreur = false;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}
			break;	
		case "GPE_CHECKEDALL":
			if(FormElement.checked == true)
			{
				Erreur = false;
			}
			else
			{
				Erreur = true;
			}
			if(CurrentError < 2)
			{
				Erreur = Erreur | CurrentError;
			}	
			break;
		case "RB_CHECKED":
			Erreur = true;
			for(Index = 0; Index < FormElement.length; Index++)
			{
				if(FormElement[Index].checked == true)
				{
					Erreur = false;
				}				
				if(Erreur == false)
				{
					break;
				}
			}
			break;
		case "RB_NOCHECKED":
			Erreur = false;
			for(Index = 0; Index < FormElement.length; Index++)
			{
				if(FormElement[Index].checked == true)
				{
					Erreur = true;
				}
				
				if(Erreur == true)
				{
					break;
				}
			}			
			break;	
		default:
			//$ Test si le selectIndex est different de
			ExpReg = "^NOSELECT\\((\.+)\\)"; //$ NOSELECT(1, 2, 3);
			if(TypeTest.match(ExpReg) != null)
			{
				//$ Récupération des champs à comparer
				Value = RegExp.$1;
				TblComparaison = Value.split(",");
				
				//$ Retirer les espaces	
				TblComparaison = RetireEspace(TblComparaison);
				for(Index = 0; Index < TblComparaison.length; Index++)
				{
					if(FormElement.selectedIndex == TblComparaison[Index])
					{
						Erreur = true;
						break;
					}					
				}
				if(CurrentError < 2)
				{
					Erreur = Erreur | CurrentError;
				}
				break;
			}	
			
			//$ Test si le selectIndex est égale à
			ExpReg = "^SELECT\\((\.+)\\)"; //$ SELECT(1, 2, 3);
			if(TypeTest.match(ExpReg) != null)
			{
				//$ Initialisation de l'erreur
				Erreur = true;
				//$ Récupération des champs à comparer
				Value = RegExp.$1;
				TblComparaison = Value.split(",");
				
				//$ Retirer les espaces	
				TblComparaison = RetireEspace(TblComparaison);
				for(Index = 0; Index < TblComparaison.length; Index++)
				{
					if(FormElement.selectedIndex == TblComparaison[Index])
					{
						Erreur = false;
						break;
					}					
				}
				if(CurrentError < 2)
				{
					Erreur = Erreur | CurrentError;
				}
				break;
			}
				
			//$ Test si c'est un test pour une longueur minimum
			ExpReg = "^MIN\\((\\d+)\\)"; //$ MIN(12);
			if(TypeTest.match(ExpReg) != null)
			{
				if(FormElement.value.length < RegExp.$1)
				{
					Erreur = true;
				}
				if(CurrentError < 2)
				{
					Erreur = Erreur | CurrentError;
				}	
				break;
			}
			
			//$ Test si c'est un test pour une longueur maximum
			ExpReg = "^MAX\\((\\d+)\\)"; //$ MAX(12);
			if(TypeTest.match(ExpReg) != null)
			{
				if(FormElement.value.length > RegExp.$1)
				{
					Erreur = true;
				}
				if(CurrentError < 2)
				{
					Erreur = Erreur | CurrentError;
				}	
				break;
			}
			
			//$ Test si c'est un test pour une comparaison
			ExpReg = "^IDEM\\((\.+)\\)"; //$ IDEM(test, test1, test2);
			if(TypeTest.match(ExpReg) != null)
			{
				//$ Récupération des champs à comparer
				Value = RegExp.$1;
				TblComparaison = Value.split(",");
				
				//$ Retirer les espaces	
				TblComparaison = RetireEspace(TblComparaison);
				
				Comparaison1 = Form.elements[TblComparaison[0]].value;
				for(Index = 1; Index < TblComparaison.length; Index++)
				{
					Comparaison2 = Form.elements[TblComparaison[Index]].value;
					if(Comparaison1 != Comparaison2)
					{
						Erreur = true;
					}
					Comparaison1 = Comparaison2;
				}
				break;
			}
			
			//$ Test si c'est un test sur le format
			ExpReg = "^FORMAT\\((\.+)\\)"; //$ FORMAT(\\d\\d-\\d\\d-\\d\\d\\d\\d)
			if(TypeTest.match(ExpReg) != null)
			{
				//$ Si la valeur n'est pas vide
				if(FormElement.value != "")
				{
					//$ Preparer l'expression régulière
					ExpReg = "^" + RegExp.$1 + "$";
				
					//$ Si le format ne correspond pas
					if(String(FormElement.value).match(ExpReg) == null)
					{
						Erreur = true;
					}
				}				
				if(CurrentError < 2)
				{
					Erreur = Erreur | CurrentError;
				}
				break;						
			}

			//$ Test si c'est un test sur le format
			ExpReg = "^DATE\\((\.+)\\)"; //$ DATE(DD/MM/YYYY)
			if(TypeTest.match(ExpReg) != null)
			{
				if(FormElement.value == "")
				{
					if(CurrentError < 2)
					{
						Erreur = Erreur | CurrentError;
					}
					break;
				}
				
				///$ Récupération des informations du format
				Value = RegExp.$1;
				TblComparaison = Value.split(",");
				
				//$ Retirer les espaces	
				TblComparaison = RetireEspace(TblComparaison);
				
				//$ initlialisation du format et du séparateur
				Format = TblComparaison[0];
				Separateur = TblComparaison[1];
				TblFormat = Format.split(Separateur);
				TmpTemp = FormElement.value.split(Separateur);

				if(TblFormat.length != TmpTemp.length)
				{
					Erreur = true;
					if(CurrentError < 2)
					{
						Erreur = Erreur | CurrentError;
					}
					break;
				}				
								
				for(Index = 0; Index < TblFormat.length; Index++)
				{
					if(VerifOnlyNum(TmpTemp[Index]))
					{
						Erreur = true;
						if(CurrentError < 2)
						{
							Erreur = Erreur | CurrentError;
						}
						break;	
					}
					
					//$ Si jour
					if(TblFormat[Index].indexOf("D") != -1)
					{
						if((TmpTemp[Index] < 1) || (TmpTemp[Index] > 31))
						{
							Erreur = true;
							if(CurrentError < 2)
							{
								Erreur = Erreur | CurrentError;
							}
							break;
						}
						continue;
					}
						
					//$ Si mois
					if(TblFormat[Index].indexOf("M") != -1)
					{
						if((TmpTemp[Index] < 1) || (TmpTemp[Index] > 12))
						{
							Erreur = true;
							if(CurrentError < 2)
							{
								Erreur = Erreur | CurrentError;
							}
							break;
						}
						continue;
					}
				}			
				
				
				break;						
			}
		
		//$ Si le Type de test n'existe pas, afficher une erreur
		alert("Error test '" + TypeTest + "'");
		Erreur = true;
		break;
	}
	
	//$ Renvoi de l'erreur
	return Erreur;
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui ouvre une nouvelle fenêtre
//$=========================================================================================
//$=========================================================================================
function OuvreWindow(url, name, option)
{
	// Ouverture de la fenêtre
	new_window = open(url, name, option);
	new_window.creator = self;
}
//$=========================================================================================
//$=========================================================================================


//$=========================================================================================
//$=========================================================================================
//$ Fonction qui retire les espaces au début et à la fin
//$=========================================================================================
function RetireEspace(TblChampATest)
{
	//$ Declaration des variables locales
	var Index;
	
	//$ Verification des champs
	for(Index = 0; Index < TblChampATest.length; Index ++)
	{
		//$ Definition du nom du champ
		NomChamp = TblChampATest[Index];

		//$ Retirer les blancs au début et à la fin
		reg = /^\s*/gi;
		NomChamp = NomChamp.replace(reg, "");
		reg = /\s+$/gi;
		NomChamp = NomChamp.replace(reg, "");
		TblChampATest[Index] = NomChamp;
	}
	
	//$ Renvoi du tableau converti
	return TblChampATest;	
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si la saisie du mail est correcte
//$=========================================================================================
function VerifMail(ch)
{
	//$Initialisation des variables locales
	var v = 0;
	var res = "";
	var erreur = 0;
	var compteur = 0;
	var email;
	var tbl_email;
	
	//$Initialisation du tableau d'adresses e-mail
	tbl_email=ch.split(GEN_MailSep);

	//$Tant qu'il y a des adresses a tester et qu'auccune erreur n'est trouvee
	while((compteur < tbl_email.length) && (erreur == 0))
	{
		//$initialisation du compteur d'@ dans l'adresse e-mail
		v = 0;
		
		//$Initialisation de la nouvelle adresse e-mail a tester
		email=tbl_email[compteur];
		
	    if(email.length != 0)
	    {
		    //$ on verifie si la chaine email contient plus de un "@"
		    tbl1 = email.split("@");
		    for(var u=0; u <email.length;u++)
		    {
		    	var ar=email.substring(u,u+1);
		    	if(ar=="@")
		        {
		        	v=v+1;
		        }
		        if(v>1)
		        {
		        	
		        	erreur= 1;
		        } 
		    }
		    
		    //$ on verifie si la chaine email contient au moins un "@", si elle n'est pas vide,
		    //$ si avant "@" et après "@" il y a des caractères 
		    if(email == "" || email.indexOf('@',0) == -1 || tbl1[0] == "" || tbl1[1] == "")
		    {
		    	erreur= 1;
		    }
		    else
		    {
		    	tbl2 = tbl1[1].split(".");
		        for(var i=0; i<tbl1[0].length;i++)
		        {
		        	a=tbl1[0].charAt(i);
		            if(GEN_BadMail.indexOf(a)>-1)
		            {
		            	erreur= 1;
		            }       
		        }
		        for(var j=0; j<tbl1[1].length;j++)
		        {
		        	b=tbl1[1].charAt(j);
		            if(GEN_BadMail.indexOf(b)>-1)
		            {
		            	erreur= 1;
		            }
		        }
		        if(tbl1[1].indexOf('.',0)==-1 ||tbl2[0]==""|| tbl2[1]=="")
		        {
		        	erreur= 1;
		        }
		        else
		        {
		        	for(var k=0; k<tbl2[0].length;k++)
		            {
		            	c=tbl2[0].charAt(k);
		                if(GEN_BadMail.indexOf(c)>-1)
		                {
		                	erreur= 1;
		                }
		            }
		            for(var l=0; l<tbl2[1].length;l++)
		            {
		            	d=tbl2[1].charAt(l);
		                if(GEN_BadMail.indexOf(d)>-1)
		                {
		                	erreur= 1;
		                }
		            }
		        }
		    }
		    
		    for(var e=0; e<email.length;e++)
		    {
		    	z=email.charAt(e);
		        if(GEN_BadMail.indexOf(z)>-1)
		        {
		        	erreur= 1;
		        }
		    }
		}
	    	    
	    //$incrementation du compteur d'adresse e-mail
	    compteur++;
	}
	
	return erreur; 
}
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si le champs contient des chiffre et des lettres
//$=========================================================================================
function VerifNumChar(FormNumChar)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = true;
	
	FormNumChar = FormNumChar.toUpperCase();
	for (Index = 0; Index < FormNumChar.length; Index++)
	{
		Info = FormNumChar.charAt(Index);

		if(GEN_NumChars.indexOf(Info) != -1)
		{
			Num = true;
		}  
		else
		{             
			if(GEN_CharChars.indexOf(Info) != -1)
			{
				Char = true;
			}
			else
			{
				Char =  false;
				break;
			} 
		}
  }
  
  if(Num && Char)
	{
		Erreur = false;
	}
  
  if(FormNumChar.length == 0)
  {
  	Erreur = false;
  }
  
  //$ Renvoi de l'erreur
  return Erreur;
	
}   
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si le champs contient un chiffre
//$=========================================================================================
function VerifNum(FormNum)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = true;
	
	for (Index = 0; Index < FormNum.length; Index++)
	{
		Info = FormNum.charAt(Index);
		if(GEN_NumChars.indexOf(Info) != -1)
		{
			Erreur = false;
		}               

		if(Erreur == false)
		{
			break;
		}
  } 
  
  if(FormNum.length == 0)
  {
  	Erreur = false;
  }
  
  //$ Renvoi de l'erreur
  return Erreur;                
}  
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui test que le champ contient que des chiffres
//$=========================================================================================
function VerifOnlyNum(FormNum)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = false;
	
	for (Index = 0; Index < FormNum.length; Index++)
	{
		Info = FormNum.charAt(Index);
		if(GEN_NumChars.indexOf(Info) == -1)
		{
			Erreur = true;
		}               
				
		if(Erreur == true)
		{
			break;
		}
  } 
  
  if(FormNum.length == 0)
  {
  	Erreur = false;
  }
  
  //$ Renvoi de l'erreur
  return Erreur;                
}  
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si le champs ne contient pas de chiffres
//$=========================================================================================
function VerifNoNum(FormNoNum)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = false;

	for (Index = 0; Index < FormNoNum.length; Index++)
	{
		Info = FormNoNum.charAt(Index);
		if(GEN_NumChars.indexOf(Info) != -1)
		{
			Erreur = true;
		}               
				
		if(Erreur == true)
		{
			break;
		}
  }  
  
  //$ Renvoi de l'erreur
  return Erreur;	
}  
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si le champs contient bien un alphanumerique ( de A à Z )
//$=========================================================================================
function VerifChar(FormChar)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = true;
	
	FormChar = FormChar.toUpperCase();
	for (Index = 0; Index < FormChar.length; Index++)
	{
		Info = FormChar.charAt(Index);
		if(GEN_CharChars.indexOf(Info) != -1)
		{
			Erreur = false;
		}               
				
		if(Erreur == false)
		{
			break;
		}
  } 
    
	if(FormChar.length == 0)
	{
		Erreur = false;
	}
    
  //$ Renvoi de l'erreur
  return Erreur;                
}  
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie qu'il n'y a que des caractères alphanumerique
//$=========================================================================================
function VerifOnlyChar(FormChar)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = false;
	
	FormChar = FormChar.toUpperCase();
	for (Index = 0; Index < FormChar.length; Index++)
	{
		Info = FormChar.charAt(Index);
		if(GEN_CharChars.indexOf(Info) == -1)
		{
			Erreur = true;
		}               
				
		if(Erreur == true)
		{
			break;
		}
  } 
    
  //$ Renvoi de l'erreur
  return Erreur;                
}  
//$=========================================================================================
//$=========================================================================================

//$=========================================================================================
//$=========================================================================================
//$ Fonction qui vérifie si le champs ne contient pas de caractere alphanumerique ( de A à Z )
//$=========================================================================================
function VerifNoChar(FormNoChar)
{
	//$ Déclaration des variables locales
	var Index;
	var Num = false;
	var Char = false;
	var Info;
	var Erreur = false;
	
	FormNoChar = FormNoChar.toUpperCase();
	for (Index = 0; Index < FormNoChar.length; Index++)
	{
		Info = FormNoChar.charAt(Index);
		if(GEN_CharChars.indexOf(Info) != -1)
		{
			Erreur = true;
		}               
				
		if(Erreur == true)
		{
			break;
		}
  } 
    
  //$ Renvoi de l'erreur
  return Erreur;
	
}   
//$=========================================================================================
//$=========================================================================================