//$========================================================================================= 
//$ 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; 
	var iIndex;
				 
	//$ 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 
			if(TypeTest == "CHECKED")
			{
			  ReturnError = true;
			  for(iIndex = 0; iIndex < Form.length; iIndex++)
			  {
			    if((Form.elements[iIndex].name == Element) && (Form.elements[iIndex].checked == true))
			    {
			      ReturnError = false;
			    }
			  }
			}
			else 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 
//$=========================================================================================