// -----------------------------------------------------------------------
// Auteur : Internet Solutions, 18 Bd de Reuilly 75012 PARIS
// Email : info@internet-solutions.fr	
// Date : Aout 2005
// Toute reproduction ou modification intégrale ou partielle est interdite
// sans un accord préalable et écrit d Internet Solutions
// -----------------------------------------------------------------------
//*******************************************************************************************
//	Script :		CheckForm
//	Version :		1.0.0
//	MAJ par :		Internet Solutions
//	MAJ le :		28/09/05
//	Description :	Fonctions de validation clientes des données de formulaires
//*******************************************************************************************

//*******************************************************************************************
// inclusion des bibliothèques de fonctions et de constantes
//
// --> CheckDataType
// --> CheckEmpty   
// --> CheckMaxSelected
// --> CheckMaxLength
// --> CheckSelectionCombo
// --> CheckSelectionValCombo
// --> CheckMaxSelectedMult
// --> CheckSameName 
// --> CheckMaxLengthSameName
// --> CheckScale (Vérifie si le champ minimum d'une échelle est inférieur au champ maximum)
// --> CheckRange(obj_HTMLElement, str_fieldName , vnt_minValue, vnt_maxValue [, bln_isDate])
//
//*******************************************************************************************

//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckDataType(obj_HTMLElement, str_fieldName, int_dataType)
//
//	Objet :			Vérifie le type de données contenu dans l'élément HTML
//
//	Appliquée à :	- TextArea
//                  - input type = text
//                  - input type = password  
//
//	Entrées :		- obj_HTMLElement (type objet) : objet HTML à vérifier
//					- str_fieldName (type string)  : intitulé du champ à vérifier
//					- int_dataType (type integer)  : types de données autorisées (cf: constantes)
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************

function CheckDataType(obj_HTMLElement, str_fieldName, int_dataType)
{
	if (typeof(obj_HTMLElement) != 'object')
	{
	//**************************************************************************
	//	Données de type date limitées aux formats date (jj/mm/aaaa, jj/mm/aa)
	//**************************************************************************		

		var str_characters = obj_HTMLElement;
			
		var str_Date = "0123456789/"; //caractères autorisés dans la chaine Date
		if (!IsStringOK(str_characters, str_Date)) //test sur la validité des caractères de la date
		{
			alert(err_InvalidDate + err_DateAccept1);
			return false;
		}

		var arr_Date = str_characters.split('/');

		if (arr_Date.length == 3)
		{
			if ((arr_Date[0].length != 1 && arr_Date[0].length != 2) ||
				(arr_Date[1].length != 1 && arr_Date[1].length != 2) ||
				(arr_Date[2].length != 2 && arr_Date[2].length != 4))
			{
				alert(err_InvalidDate + err_DateAccept2);
				return false;
			}
						
			var int_day = parseInt(arr_Date[0],10);
			var int_month = parseInt(arr_Date[1],10);
			var int_year = parseInt(arr_Date[2],10);
			var int_strYear = int_year.length;

			if ((int_day < 1) || (int_day > 31)) //test sur la valeur possible du jour
			{
				alert(err_InvalidDate + err_DateAccept3);
				return false;
			}
	
			if ((int_month < 1) || (int_month > 12)) //test sur la valeur possible du mois
			{
				alert(err_InvalidDate + err_DateAccept4);
				return false;
			}

			if (int_month == 4 || int_month == 6 || int_month == 9 || int_month == 11)
				if (int_day > 30)
				{
					alert(err_InvalidDate + err_DateAccept5);
					return false;
				}

			if (int_month == 2)
			{
				if (int_day > 29)
				{
					alert(err_InvalidDate + err_DateAccept6);
					return false;
				}
				else
				{
					if (int_day == 29)
					{
						var int_reste = int_year % 4;
						if (int_reste != 0)
						{
							alert(err_InvalidDate + err_DateAccept7);
							return false;
						}
					}
				}
			}
		}
		else
		{
			alert(err_InvalidDate + err_DateAcceptFalse);
			return false;
		}

		return true;

	//**************************************************************************
	//	Fin condition cstDataDate
	//**************************************************************************	
	}
	else
	{	
		var str_charactAlphaNum;
		var int_charactInteger;
		var str_charactNumber;
		var sng_charactReal;
		var int_pointPosition;
		var int_commaPosition;
		var int_nbPoints;
		var int_nbCommas;
		var int_nbAt;
		var str_characters = obj_HTMLElement.value;
	
		// Différents types de données :

		switch (int_dataType)
		{
		//*******************************************************************************
		//	Données Alphanumériques limitées aux Alphanumériques de (0-9) (a-z) (A-Z) ()
		//*******************************************************************************

			case cstDataAlphaNum :
				//Chaine de référence autorisée:
				str_charactAlphaNum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'`´‘’- \t\r\n\f";

				if (!IsStringOK(str_characters, str_charactAlphaNum))
				{
					alert(err_Str0To9 + err_StrEtLiaison + err_StrAlphabet + "\n" + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataAlphaNum
		//**************************************************************************
		
		//*******************************************************************************
		//	Données Alphanumériques limitées aux Alphanumériques (a-z) (A-Z) ()
		//*******************************************************************************

			case cstDataAlpha :
				//Chaine de référence autorisée:
				str_charactAlpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'`´‘’- \t\r\n\f";

				if (!IsStringOK(str_characters, str_charactAlpha))
				{
					alert(err_StrAlphabet + "\n" + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataAlpha
		//**************************************************************************
	
		//**************************************************************************
		//	Données de type Entier limitées aux entiers de (0-9)
		//**************************************************************************
						
			case cstDataInteger :
				//Chaine de référence autorisée:
				int_charactInteger = "0123456789"
			
				if (!IsStringOK(str_characters, int_charactInteger))
				{
					alert(err_Str0To9 + " " + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataInteger
		//**************************************************************************
			
		//**************************************************************************
		//	Données de type nombre limitées aux Nombres de (0-9) et à l'espace
		//**************************************************************************
			
			case cstDataNumber : 
				//Chaine de référence autorisée:
				str_charactNumber = "0123456789 "
			
				if (!IsStringOK(str_characters, str_charactNumber))
				{
					alert(err_Str0To9 + err_StrSpace + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;							

		//**************************************************************************
		//	Fin case cstDataNumber
		//**************************************************************************		
		
		//**************************************************************************
		//	Données de type nombre limitées aux Nombres de (0-9) et à l'espace et point virgule pour autoriser une recherche
		// sur des code postaux séparés par un point virgule
		//**************************************************************************
			
			case cstDataNumberCP : 
				//Chaine de référence autorisée:
				str_charactNumber = "0123456789 ;"
			
				if (!IsStringOK(str_characters, str_charactNumber))
				{
					alert('Vous ne pouvez saisir que des chiffres dans le champ Code postal.');
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;							
				
		//**************************************************************************
		//	Fin case cstDataNumberCP
		//**************************************************************************	
		
		//**************************************************************************
		//	Données de type réel limitées aux réels et caractères '.' ou ',' et l'espace
		//**************************************************************************
				
			case cstDataReal :
				//Chaine de référence autorisée:
				sng_charactReal = "0123456789., "
				int_nbPoints = CountOccurrences(str_characters, '.'); //Nombre de points dans le nombre reel saisie.
			
				if (!IsStringOK(str_characters,sng_charactReal))
				{
					alert(err_Str0To9 + err_StrPointComma + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 

				//cas où le '.' ou ',' est au début de la chaine
				
					int_pointPosition = str_characters.indexOf('.',0);
					int_commaPosition = str_characters.indexOf(',',0); 

					if ((int_pointPosition == 0)||(int_commaPosition == 0))
					{
						alert(err_NotCorrectFill + "\n" + err_NoNumBeforeComma + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
					
	
				//on teste qu'il y a quelque chose après le '.'

					if ( (int_pointPosition == (str_characters.length - 1)&& ((str_characters.length - 1) >= 0)) 
						|| 
						(int_commaPosition == (str_characters.length - 1) && ((str_characters.length - 1) >= 0)) )
					{
						alert(err_NotCorrectFill + "\n" + err_NoNumAfterComma + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
					

				//Calcul du nombre d'occurences '.' ou ',' dans la chaine:
				
					int_nbCommas = CountOccurrences(str_characters,',');
					
					if ((int_nbPoints > 1) || (int_nbCommas > 1))
					{ 
						alert(err_NotCorrectFill + "\n" + err_TooManyDots + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
					return true;	

		//**************************************************************************
		//	Fin case cstDataReal
		//**************************************************************************


		//*******************************************************************************
		//	Données Alphanumériques autorisant la plupart des caractères
		//*******************************************************************************

			case cstDataAutorizedText :
				//Chaine de référence autorisée:
				str_charactAutorizedText = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ@£$€=-+_*&'`´‘’()!?-.,;:/\\\" \t\r\n\f";

				if (!IsStringOK(str_characters, str_charactAutorizedText))
				{
					//alert(err_Str0To9 + err_StrEtLiaison + err_StrAlphabet + err_StrEtLiaison + err_StrPointComma + "\n" + err_Accept + err_Field + str_fieldName + err_Dot);
					alert(err_CharError+ ' (' + str_fieldName +')');
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataAutorizedText
		//**************************************************************************
		
		//*******************************************************************************
		//	Données Alphanumériques interdites
		//*******************************************************************************
			
			case cstDataProhibedText :
				//Chaine de référence des caractères interdits:
				var str_charactNotAutorized, Lib_charactNotAutorized;
				Lib_charactNotAutorized =  ' \'<\', \'/\', \'\\\', \'>\' ';
				str_charactNotAutorized = '</\\>';
				
				if (!IsStringNotOK(str_characters, str_charactNotAutorized))
				{
					alert(err_strLes + err_Char+ ' (' + Lib_charactNotAutorized  + ')' + err_Prohibited + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataProhibedText
		//**************************************************************************

		//**************************************************************************
		//	Données de type EMail limitées au format EMail
		//**************************************************************************		
			
				case cstDataEmail : 
				
				var str_StringMailOk = "0123456789azertyuiopqsdfghjklmwxcvbnAZERTYUIOPQSDFGHJKLMWXCVBN_.-@";
				var int_nbAt = CountOccurrences(str_characters,'@'); //Nombre d'occurences du caractère '@'
				var tab_Strings_1 = str_characters.split("@"); //tableau regroupant les différentes sous-chaines issues du fractionnement de l'adresse mail (fractions au niveau du '@')
				var int_i;
				var str_CharacMail = "azertyuiopqsdfghjklmwxcvbnAZERTYUIOPQSDFGHJKLMWXCVBN";
 				
				if (IsStringOK(str_characters,str_StringMailOk))
				{	
					if (int_nbAt == 1)
					{
						
						//Test à partir du fractionnement de la chaine adresse mail en deux sous chaines au niveau du '@'
						if ((tab_Strings_1[0] != "") && (tab_Strings_1[1] != ""))
						{
							if ((IsFirstLastStringOK(tab_Strings_1[0])) && (IsFirstLastStringOK(tab_Strings_1[1])))
							{
								var tab_Strings_2 = (tab_Strings_1[1]).split("."); //tableau regroupant les différentes sous-chaines issues du fractionnemant de la chaine de caractère précédent le '@' (fractions au niveau du '.')  
								//Test à partir du  fractionnement la chaine située à droite de l'@' au niveau du '.'
								if (tab_Strings_2.length > 1)
								{
									for (int_i = 0; int_i < tab_Strings_2.length; int_i++)
									{
										if (!(IsFirstLastStringOK(tab_Strings_2[int_i]) && tab_Strings_2[int_i] != ""))
										{
										  	alert(err_InvalidMail + err_Field + str_fieldName + err_Dot);
											obj_HTMLElement.focus();
											return false;
										}
									}
								}
								else
								{
									alert(err_InvalidMail + err_Field + str_fieldName + err_Dot);
									obj_HTMLElement.focus();
									return false;
								}

								var int_NbCharLastElement = (tab_Strings_2[tab_Strings_2.length - 1]).length;	
								if (int_NbCharLastElement <= 4)
								{
									// test sur le dernier élément de la chaine située à droite de l'@ (limité à 4 caractères max) :
									if (IsStringOK((tab_Strings_2[tab_Strings_2.length - 1]),str_CharacMail))
									{
										return true;
									}
								}
							}
						}
					}
				}
				
				alert(err_InvalidMail + err_Field + str_fieldName + err_Dot);
				obj_HTMLElement.focus();
				return false;
	
		//**************************************************************************
		//	Fin case cstDataEmail
		//**************************************************************************		
	
		//*******************************************************************************
		//	Données Alphanumériques pour les mots de passe et Password (0-9) (a-z) (A-Z)
		//*******************************************************************************

			case cstDataIdPwd :
				//Chaine de référence autorisée:
				str_charactAutorizedText = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzƒŠŒŽšœžŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ";

				if (!IsStringOK(str_characters, str_charactAutorizedText))
				{
					alert(err_Str0To9 + err_StrEtLiaison + err_StrAlphabet + "\n" + err_Accept + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}	 
				return true;

		//**************************************************************************
		//	Fin case cstDataIdPwd
		//**************************************************************************

		//**************************************************************************
		//	Données de type libre
		//**************************************************************************	
						
				case cstDataFreeText : 
					
						return true;	
	
		//**************************************************************************
		//	Fin case cstDataFreeText
		//**************************************************************************					
	
		//**************************************************************************
		//	Données de type HTML
		//**************************************************************************	
						
				case cstDataHTML : 
					
						return true;	
	
		//**************************************************************************
		//	Fin case cstDataHTML
		//**************************************************************************					

		//**************************************************************************
		//	Autres types de données
		//**************************************************************************	

				default :
				
						alert(err_DataType);
						obj_HTMLElement.focus();
						return false;

		//**************************************************************************
		//	Fin Autres types de données
		//**************************************************************************	
		}
	}
}

//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckEmpty(obj_HTMLElement, str_fieldName)
//
//	Objet :			Vérifie si le champ est vide
//
//	Appliquée à :	- textArea
//					- select
//					- input type=text
//					- input type=password
//					- input type=radio
//					- input type=hidden
//
//	Entrées :		- obj_HTMLElement (type objet) : objet HTML à vérifier
//					- str_fieldName (type string) : intitulé du champ à vérifier
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************

function CheckEmpty(obj_HTMLElement, str_fieldName)
{	
	var int_option;

	var str_type = obj_HTMLElement.type;

	if(str_type == null)
	{
		if(obj_HTMLElement[0].type != "radio") //  si l'objet n'est pas un bouton radio
		{
			alert(err_Object);
			return false;
		}
		else // si l'objet est une collection de bouton radio
		{
			for(i = 0; i < obj_HTMLElement.length; i++) // on recherche si l'utilisateur a choisi une option
			{
				if(obj_HTMLElement[i].checked == true)
				{
					return true;
				}
			}
			alert(err_SelOption + err_Field + str_fieldName + err_Dot);
			return false;
		}
	}
	else // on teste les autres objets
	{
		// dans le cas d'une combo multiple ou non
		if(str_type == "select-one" || str_type == "select-multiple")
	  	{	
			int_option = obj_HTMLElement.options.selectedIndex;
			
			// si aucune option n'est selectionnee 
			if((str_type == "select-multiple" && int_option == -1) || (str_type == "select-one" && obj_HTMLElement.options[int_option].value == ""))
			{
				alert(err_SelOption + err_Field  + str_fieldName + err_Dot);
				obj_HTMLElement.focus();
				return false;
			}
			
			// si le champ value est = 0 ou vide
			if(obj_HTMLElement.options[int_option].value == "" || obj_HTMLElement.options[int_option].value == 0)
			{
		 		alert(err_SelOption + err_Field  + str_fieldName + err_Dot);
				obj_HTMLElement.focus();
				return false;
			}															 
			return true;
		}
		
		// pour tout le reste text, textarea, password, hidden, file
		if(str_type == "text" || str_type == "textarea" || str_type == "password" || str_type == "hidden" || str_type == "file")
		{
			if (ContainOnlySpaces(obj_HTMLElement.value) || obj_HTMLElement.value == "")
			{
				alert(err_EnterValue + err_Field  + str_fieldName + err_Dot);
				if(str_type != "hidden")
				{
					obj_HTMLElement.focus();
				}
				return false;
			}
			return true;
		}
	}

	alert(err_Object);
	return false;
}	


//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckMaxSelected(obj_HTMLElement, str_fieldName, int_maxSelected, bln_typeCombo)
//
//	Objet :			Vérifie le nombre d'éléments sélectionnés ou non dans une liste multiple
//
//	Appliquée à :	- select multiple
//
//	Entrées :		- obj_HTMLElement (type objet) : objet HTML à vérifier
//					- str_fieldName (type string) : intitulé du champ à vérifier
//					- int_maxSelected (type integer) : nombre maximum d'éléments (sélectionnés ou non)
//					- bln_typeCombo (type booléen) : élément selectionné (1) ou non (0))
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************

function CheckMaxSelected(obj_HTMLElement, str_fieldName, int_maxSelected, bln_typeCombo)
{
 	var i;
	var int_selected = 0;
	for(i = 0; i < obj_HTMLElement.length; i++)
	{
		if (bln_typeCombo == 1)
		{
			// on parcourt l'ensemble de la liste en incrémentant lorsqu'une option est selectionnée
			if(obj_HTMLElement[i].selected == true)
			{
				int_selected ++;
			}
		}
		else
		{
			int_selected ++;
		}
	}
									 
	// on compare au nombre de selections autorisées
	if (int_selected > int_maxSelected)
	{
		alert(err_SelLessOption + err_Field + str_fieldName + err_Dot + err_seleclimit + int_maxSelected + err_Dot);
		obj_HTMLElement.focus();
		return false;
	}

	return true;
}

//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckMaxLength(obj_HTMLElement, str_fieldName, int_length)
//
//	Objet :			Vérifie le nombre de caractères maximum
//
//	Appliquée à :	- textArea
//					- input type = hidden
//
//	Entrées :		- obj_HTMLElement (type objet) : objet HTML à vérifier
//					- str_fieldName (type string) : intitulé du champ à vérifier
//					- int_length (type integer) : longueur autorisée
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************

function CheckMaxLength(obj_HTMLElement, str_fieldName, int_length)
{
	// pour les deux objets : textaera, input type=hidden, il suffit de tester la propriete length
	// on teste donc la longueur de la chaîne
	if (obj_HTMLElement.value.length > int_length)
	{
		alert(err_Length + err_Max + int_length + err_Char + err_Field + str_fieldName + err_Dot);
		if (obj_HTMLElement.type != "hidden")
		{
			obj_HTMLElement.focus();
		}
		return false;
	}
	return true;
}

//*******************************************************************************************
//	Auteur : MARTIN Xavier
// 	Date maj : 08/10/01
//
//	Fonction :		CheckSelectionCombo(arr_TabSelec,str_fieldName)
//
//	Objet :			Vérifie si dans deux combos ou +, deux champs sont identiques.
//
//	Appliquée à :	- select
//
//	Entrées :		- arr_Selec (type tableau) : tableau des nom de form. des combos à comparer 
//					- str_fieldName (type string) : intitulé du groupe de champs à vérifier
//
//	Variable :		- int_TailleTab : taille du tableau 
//					- val_Test : valeur fixe à laquelle on teste les autres valeurs.
//					- str_Test : valeur textuelle du champ sélectionné
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************

function CheckSelectionCombo(arr_Selec,str_fieldName)
{
	arr_Valeur=new Array;
	var int_n;
	var int_j;
	var int_z;
	
	int_TailleTab = arr_Selec.length;
	
	//on crée un tableau avec les valeurs choisies dans les combo
	for(int_j=1;int_j<int_TailleTab;int_j++)
	{
			arr_Valeur[int_j]= arr_Selec[int_j].options[arr_Selec[int_j].selectedIndex].value;
	}
	//on se retrouve donc avec 1 tableau contenant les valeurs des différentes Combos
	for(int_n=1;int_n<int_TailleTab;int_n++)
	{
			val_Test = arr_Valeur[int_n];
			str_Test = arr_Selec[int_n].options[arr_Selec[int_n].selectedIndex].text;
			
			for(int_z=1;int_z<int_TailleTab;int_z++)
			{
				//on ne teste que les valeurs qui n'ont pas le même indice dans le tableau
				if(int_n!=int_z)
					{
					//si les deux valeurs sont remplies(<>0) et égales->message d'erreur
					if((val_Test==arr_Valeur[int_z]) && (val_Test!=0))
						{
						alert(err_Seldouble + str_Test + err_Field + str_fieldName);
						arr_Selec[int_z].options[0].selected=true;
						arr_Selec[int_z].focus();
						return false;
						}
					}
			}
	}
	return true;
}

//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckSelectionValCombo(arr_TabSelec,str_fieldName)
//
//	Objet :			Vérifie si dans deux combos (ou +)qui ne sont pas Numérotée , deux champs sont identiques.
//					
//	Entrées :		- arr_Selec (type tableau) : tableau qui doit contenir les index des valeurs des combos
//					- str_fieldName (type string) : intitulé du groupe de champs à vérifier
//
//	Sortie :		- affichage d'un message d'erreur avec explications
//					- true sinon
//*******************************************************************************************

function CheckSelectionValCombo(arr_Selec,str_fieldName)
{
	var int_i;
	var int_j;
	var int_TailleTab;
	var int_Res;
	//initialisation de la variable qui définie la taille du tableau
	int_TailleTab = arr_Selec.length;
	
	//on va tester la valeur du premier indice avec la valeur des indices suivants, puis 
	//				la valeur du second indice avec la valeur des indices suivants, etc..
	//Si on trouve une égalité alors il y a un doublon 
	for(int_i=0;int_i<int_TailleTab;int_i++)
	{
			// Initialisation de la valeur de référence qui sera comparée aux autres
			int_Res = arr_Selec[int_i];
			
			//Boucle qui va permettre de faire la comparaison
			for(int_j=int_i + 1; int_j<int_TailleTab; int_j++)
			{
				//alert ('int_Res = ' + int_Res);
				//alert ('arr_Selec[int_j] = ' + arr_Selec[int_j]);
				if (int_Res == arr_Selec[int_j])
				{
					alert(err_Seldouble + '\n' + err_Field + ': ' + str_fieldName);
					return false;
				}
			}
	}
	
return true;
}


//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckMaxSelectedMult(Array_obj_HTMLElement, int_maxSelected)
//
//	Objet :			Vérifie si le nombre d'éléments sélectionnés dans une ou plusieure(s) combo(s) double(s) est inférieur à une borne
//
//	Appliquée à :	- select multiple
//
//	Entrées :		- Array_obj_HTMLElement (type objet) : Tableau d'objets HTML à vérifier
//					- int_maxSelected (type integer) : nombre maximum d'éléments (sélectionnés ou non)
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur le premier élément du tableau 
//					true sinon
//*******************************************************************************************
function CheckMaxSelectedMult(Array_obj_HTMLElement, int_maxSelected)
{
 	var i;
 	var j;
	var int_selected = 0;
	var obj_HTMLElement;
	
	for(j = 0; j < Array_obj_HTMLElement.length; j++)
	{
		//Pour chaque objet du tableau et s'il existe
		
		obj_HTMLElement = Array_obj_HTMLElement[j];
		if (typeof(obj_HTMLElement) == 'object')
			{
				if (obj_HTMLElement.length > 0)
				{
					for(i = 0; i < obj_HTMLElement.length; i++)
					{
						int_selected ++;
					}
				}
			}
	}

	// on compare au nombre de selections autorisées
	if (int_selected > int_maxSelected)
	{
		alert(err_SelLessOption + err_Dot + err_seleclimit + int_maxSelected + err_Dot);
		//Array_obj_HTMLElement[0].focus();
		return false;
	}

	return true;
}


//**function CheckSameName  ********************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction	: CheckSameName
//
//	Objet		: Détecte les caractéres interdits dans des contrôles contenant une chaîne de caractères 
//				  et portant le même nom
//
//	Appliquée à :	- input type text ou textarea
//
//	Entrées		:	- theForm : Nom du formulaire
//					- str_Name_HTMLElement  : Nom des contrôles
//					
//	Sortie		:	si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - Focus sur le contôle
//					true sinon
//*******************************************************************************************
function CheckSameName (theForm, str_Name_HTMLElement)
{
	//Chaine de référence des caractères interdits:
	var str_charactNotAutorized;
	str_charactNotAutorized = '</%\>';
			
	//Boucle qui parcourt tous les contrôles du formulaire
	for (var i=0; i<theForm.elements.length; i++)
		{
			//Si le nom du contrôle parcourue est égal au nom recherché
			if (theForm.elements[i].name == str_Name_HTMLElement)
			{
				//Fonction de recherche d'un caractère interdit
				if (!(IsStringNotOK( theForm.elements[i].value , str_charactNotAutorized)))
				{
					alert(err_strLes + err_Char+ ' (' + str_charactNotAutorized  + ')' + err_Prohibited + str_Name_HTMLElement);
					theForm.elements[i].focus();
					return false;
				}	 
			}
		}
return true;
}


//**function CheckMaxLengthSameName*************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction	: CheckMaxLengthSameName
//
//	Objet		: Vérifie la longueur d'une chaine de caractères dans des contrôles type texarea portant le même nom
//
//	Appliquée à :	-  textarea
//
//	Entrées		:	- theForm : Nom du formulaire
//					- str_Name_HTMLElement  : Nom des contrôles
//					- int_length (type integer) : longueur autorisée
//					
//	Sortie		:	si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - Focus sur le contôle
//					true sinon
//*******************************************************************************************

function CheckMaxLengthSameName(theForm, str_Name_HTMLElement, int_length)
{	
	//Boucle qui parcourt tous les contrôles du formulaire
	for (var i=0; i<theForm.elements.length; i++)
		{
			//Si le nom du contrôle parcourue est égal au nom recherché
			if (theForm.elements[i].name == str_Name_HTMLElement)
			{
					if (theForm.elements[i].value.length > int_length)
					{
						alert(err_Length + err_Max + int_length + err_Char + err_Field + str_Name_HTMLElement + err_Dot);
						theForm.elements[i].focus();
						return false;
					}
			}
		}
	return true;
}

function CheckScale(str_HTMLElement, str_fieldName, bln_isDate)
//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckScale(str_HTMLElement, str_fieldName [, bln_isDate])
//
//	Objet :			Vérifie si le champ minimum d'une échelle est inférieur au champ maximum
//
//	Appliquée à :	- input type=text
//					- select simple
//
//	Entrées :		- str_HTMLElement (type string) : nom du groupe d'objets HTML à vérifier
//					- str_fieldName (type string) : intitulé du champ à vérifier
//					- bln_isDate (type boolean) : si c'est une date
//					défaut : false
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//*******************************************************************************************
{
	var obj_Min, obj_Max;
	var dtm_min, dtm_Max;
	var int_minValue, int_maxValue;
	
	//pour la compatibilité Netscape/IE
	//mise en commentaire : pour l'appel d'Id
	/*switch(BrowserSniff())
	{
		case "MOZ" : // ie5 ou ns6
		{
			obj_Min = eval("document.getElementById('" + str_HTMLElement + "Min')");
			obj_Max = eval("document.getElementById('" + str_HTMLElement + "Max')");
			break;	
		}
		case "IE" :  // ie4 (à verifier)
		{
		 	obj_Min = eval("document.all." + str_HTMLElement + "Min");
			obj_Max = eval("document.all." + str_HTMLElement + "Max");
			break;
		}
		
		default :	//autres
		{
			alert(err_Browser);
			return false;
		}
	}*/												   
	
	obj_Min = eval(str_HTMLElement + "Min");
	obj_Max = eval(str_HTMLElement + "Max");
	
	if (obj_Min.value == '' || obj_Max.value == '') return true;



	if(bln_isDate) // si on est en presence de dates
	{
		// conversion des dates
		// test si le date.parse fonctionne avec des dates françaises ou anglaises
		// l'application actuellement envoie des dates en français
		dtm_MinTest = Date.parse('04/02/2000');
		dtm_MaxTest = Date.parse('01/03/2000');
		if(dtm_MinTest > dtm_MaxTest)
		{
			//alert('Test positif : Nous devons donc tester une date anglaise\nil faut inverser Mois et Jour');
			var arr_dateMin = obj_Min.value.split("/");
			var arr_dateMax = obj_Max.value.split("/");
			var str_dateMin = arr_dateMin[1] + "/" + arr_dateMin[0] + "/" + arr_dateMin[2];
			var str_dateMax = arr_dateMax[1] + "/" + arr_dateMax[0] + "/" + arr_dateMax[2];
			//alert('obj_Min.value = ' + obj_Min.value +' \nobj_Max.value = ' + obj_Max.value );
		}
		dtm_Min = Date.parse(str_dateMin);
		dtm_Max = Date.parse(str_dateMax);
		
		//alert('dtm_Min = ' + dtm_Min +' \ndtm_Max = ' + dtm_Max );
		// on compare les deux dates : sous forme d'integer
		if(dtm_Min > dtm_Max)
		{
			alert(err_Scale + err_Field + str_fieldName + err_Dot);
			//obj_Min.focus();
			return false;
		}
		return true;
	}

	// les variables à comparer ne sont pas des dates (false si l'appelle de la fonction a un 3eme argument, null sinon)
	if(!bln_isDate || bln_isDate == null)
	{
		// ici on verifiera le type des donnees

		switch(obj_Min.type) // suivant le type d'objet on réagit de facon differentes
		{
			case "text" :
			{
				// Conversions en entier
				int_minValue = parseInt(obj_Min.value);
				int_maxValue = parseInt(obj_Max.value);
				break;
			}
			case "select-one" :
			{
				// Conversions en entier
				int_minValue = parseInt(obj_Min.options.selectedIndex);
				int_maxValue = parseInt(obj_Max.options.selectedIndex);
				break;
			}
			default :
			{
				alert(err_Object);
				return false;
			}
		}
		
		if(int_minValue > int_maxValue)
		{
			alert(err_Scale + err_Field + str_fieldName + err_Dot);
			obj_Min.focus();
			return false;
		}
		return true;
	}
}	

//*******************************************************************************************
//  Auteur : Internet Solutions
//
//	Fonction :		CheckRange(obj_HTMLElement, str_fieldName , vnt_minValue, vnt_maxValue [, bln_isDate])
//
//	Objet :			Vérifie si la valeur de l'élément HTML est comprise entre les arguments
//					valeur max. et valeur min.
//
//	Appliquée à :	- textArea
//					- input type=text
//
//	Entrées :		- obj_HTMLElement (type objet) : objet HTML à vérifier
//					- str_fieldName (type string) : intitulé du champ à vérifier
//					- vnt_minValue (type variant (date ou integer)) : valeur min. ()
//					- vnt_maxValue (type variant (date ou integer)) : valeur max.
//					[- bln_isDate (type boolean)] : si c'est une date
//					défaut : false
//
//	Sortie :		si non conforme : - false
//									  - affichage d'un message d'erreur avec explications
//									  - focus sur l'élément
//					true sinon
//******************************************************************************************

function CheckRange(obj_HTMLElement, str_fieldName , vnt_minValue, vnt_maxValue, bln_isDate)
{
  	var dtm_user;
	var int_checkNull = "";
	var int_objValue;
	var int_minValue;
	var int_maxValue;
	
	if(obj_HTMLElement.value != "") //on effectue les tests que si l'objet est renseigné
	{
		if(vnt_minValue == -1 || vnt_maxValue == -1)
		{
			if(vnt_minValue == -1)
				int_checkNull = "Min";
			else
				int_checkNull = "Max";
		} 

		if(bln_isDate) // c'est une date
		{	
			dtm_user = ConvertDate(obj_HTMLElement.value);
			
			if(int_checkNull != "") // si l'une des bornes est = '-1'
			{
				if(int_checkNull == "Min") // si la borne inferieure est = '-1'
				{
					vnt_maxValue = ConvertDate(vnt_maxValue);
					if(!CompareDate(dtm_user, vnt_maxValue))
					{
						alert(err_RangeInfDate + vnt_maxValue + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
				}
				else  // si la borne superieure est = '-1'
				{
					vnt_minValue = ConvertDate(vnt_minValue);
					if(!CompareDate(vnt_minValue, dtm_user))
					{
						alert(err_RangeSupDate + vnt_minValue + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
				}
				return true;
			}
				
			// si les 2 bornes sont != '-1'
			// on convertit les dates au format jj/mm/aaaa
			vnt_minValue = ConvertDate(vnt_minValue);
			vnt_maxValue = ConvertDate(vnt_maxValue);
			
			if(obj_HTMLElement.type == "textarea" || obj_HTMLElement.type == "text") // pour un input text ou un textarea
			{																													  
				// Si l'une des dates est en dehors de la plage spécifiée : erreur
				if(!CompareDate(dtm_user, vnt_maxValue) || !CompareDate(vnt_minValue, dtm_user))
				{
					alert(err_RangeBetweenDate + vnt_minValue + err_And + vnt_maxValue + err_Field + str_fieldName + err_Dot);
					obj_HTMLElement.focus();
					return false;
				}
				return true;
			}
			else
			{
				alert(err_Object);
				obj_HTMLElement.focus();
				return false;
			}
		}
		else // ce n'est pas une date mais un nombre
		{
			// Conversion en entier des valeurs
			int_minValue = parseInt(vnt_minValue);
			int_maxValue = parseInt(vnt_maxValue);
				
			// si on a un textarea ou un input "text" on compare les entiers
			if(obj_HTMLElement.type == "textarea" || obj_HTMLElement.type == "text")
			{
				// Conversion en entier des valeurs
				int_objValue = parseInt(obj_HTMLElement.value);	
			}
			
			if(obj_HTMLElement.type == "select-one") // idem pour le select simple
			{
				// Conversion en entier des valeurs
				int_objValue = parseInt(obj_HTMLElement.options[obj_HTMLElement.options.selectedIndex].value);
			}
			
			if(int_checkNull != "") // si l'une des bornes est = '-1'
			{
				if(int_checkNull == "Min") // si la borne inferieure est = '-1'
				{
					if(int_objValue > int_maxValue)
					{
						alert(err_RangeInf + vnt_maxValue + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
				}	
				else  // si la borne superieure est = '-1'
				{  
					if(int_objValue < int_minValue)
					{
						alert(err_RangeSup + vnt_minValue + err_Field + str_fieldName + err_Dot);
						obj_HTMLElement.focus();
						return false;
					}
				}
				return true;
			}
				
			// si les 2 bornes sont != '-1'
			if(int_objValue < int_minValue || int_objValue > int_maxValue)
			{
				alert(err_RangeBetweenNum + vnt_minValue + err_And + vnt_maxValue + err_Field + str_fieldName + err_Dot);
				obj_HTMLElement.focus();
				return false;
			}
			return true;
		}
	}
	return true;
}

//*******************************************************************************************
//	Fin : Penser à rajouter le nom de la fonction nouvelle en haut dans la liste des fonctions
//*******************************************************************************************