/*
Cree le 05/04/2003 par MB

HISTORIQUE DES MODIFICATIONS
*****************************

   // MB Modifs du 01/09/2003 :
	* Rajout de la variable bGestionModifie pour permettre d'inhiber l'affichage du message de confirmation
          -> Rajout du parametre bActiveGestionModifie a la fonction initFunction
   	* Creation de la fonction ChangeCheckBoxHiddenElement et affectation de cette fonction a
          l'evenement onClick sur les CheckBox (correction bug)
        * Modification de la fonction colorForm pour "d?colorier" les champs non obligatoires
	* Rajout du parametre frm a la fonction valideFormulaireGenerique


   // FB Modifs du 03/09/2003 :
	* dans la fonction valideFormulaireGenerique : ajout d'un code v?rifiant si le formulaire "frm" est null, 
        et si c'est le cas, affectant celui-ci ? document.forms[0]
	* Rajout des variables locales et locale et de plusieurs tableaux pour l'internationalisation des messages affich?s
	* Rajout des m?thodes setLocale et genMessage pour l'internationalisation des messages affich?s
	* Remplacement de tous les affichages d'alertes dans le but d'internationaliser ces alertes
*/


/*
   La variable debug d?termine si l'execution des fonctions contenues dans les
   fonctions Javascript d?finies ci-dessous doivent etre executees ou pas en mode debug
   Conditionne l'affichage de certains messages de debug
   Mettre cette variable ? false avant livraison
*/
var debug = false;

/*
   La variable bEstModifie permet de controler qu'une modification a ete effectuee sur un formulaire
   Elle est positionnee ? false lors du chargement du formulaire
   Elle est positionnee a true lorsqu'une modification sur le formulaire est effectuee par l'utilisateur :
   - Lors de l'evenement onChange des zones de saisies
   - Lors de l'activations des element d'aide a la saisie : calendrier, boutons d'aide.
   L'appel de la fonction annuler() controle si un changement a ete effectue (bEstModifie=true)
   Si c'est le cas, un message de confirmation est affiche.

   La variable bGestionModifie permet d'inhiber l'affichage du message de confirmation
   lorsque l'utilisateur clique sur le menu.
   En effet, sur les ecrans de type recherche, on ne veut pas afficher ce type de message
   La variable bGestionModifie est positionnee a true par defaut dans la fonction initFunction()
   Pour inhiber l'affichage du message de confirmation, on passera le parametre false a la fonction initFunction()
*/
var bGestionModifie = true;
var bEstModifie = false;

/*
   La variable locales d?finit l'ensemble des langues
   support?es par l'internationalisation JavaScript
*/
var locales = new Array ('fr', 'de', 'pl');

/*
   La variable locale d?finit la localisation courante (index dans le tableau 'locales').
   Par d?faut, il s'agit de la localication fran?aise.
*/
var locale = 0;

/*
   L'ensemble des variables suivantes sont les traductions en fran?ais et anglais des messages affich?s au client
*/
var ATTRIBUTE_MUST_NOT_HAVE_VALUE = new Array (locales.length);
ATTRIBUTE_MUST_NOT_HAVE_VALUE[0] = "Attention, l'attribut 'name' ne devrait pas être valorisé pour les checkbox pour éviter les conflits avec le champ hidden associé !";
ATTRIBUTE_MUST_NOT_HAVE_VALUE[1] = "Warning, the attribute 'name' of a checkbox should not have a value to avoid conflicts with the hidden associated field!";

var NO_ELEMENT_ASSOCIATED_TO_CHECKBOX = new Array (locales.length);
NO_ELEMENT_ASSOCIATED_TO_CHECKBOX[0] = "Attention, un élément de nom {0} devrait être associé à la checkbox !";
NO_ELEMENT_ASSOCIATED_TO_CHECKBOX[1] = "Warning, the element named {0} should be associated with the checkbox!";

var NOT_ALL_MANDATORY_ATTRIBUTES_FOR_CHECKBOX = new Array (locales.length);
NOT_ALL_MANDATORY_ATTRIBUTES_FOR_CHECKBOX[0] = "Attention, les attributs WAFCheckedElement, WAFCheckedValue et WAFUnCheckedValue doivent être définis pour la checkbox !";
NOT_ALL_MANDATORY_ATTRIBUTES_FOR_CHECKBOX[1] = "Warning, the attributes WAFCheckedElement, WAFCheckedValue and WAFUnCheckedValue must be defined for the checkbox!";

var CONTROLS_OK = new Array (locales.length);
CONTROLS_OK[0] = "Contrôles OK --> Soumission formulaire";
CONTROLS_OK[1] = "Controls OK --> Submission form";

var MISSING_MANDATORY_FIELD = new Array (locales.length);
MISSING_MANDATORY_FIELD[0] = "{0} obligatoire.\n";
MISSING_MANDATORY_FIELD[1] = "{0} is mandatory.\n";

var FIELD_MUST_BE_AN_INTEGER = new Array (locales.length);
FIELD_MUST_BE_AN_INTEGER[0] = "{0} de type entier.\n";
FIELD_MUST_BE_AN_INTEGER[1] = "{0} must be an integer.\n";

var FIELD_MUST_BE_A_DECIMAL = new Array (locales.length);
FIELD_MUST_BE_A_DECIMAL[0] = "{0} de type décimal.\n";
FIELD_MUST_BE_A_DECIMAL[1] = "{0} must be a decimal.\n";

var INVALID_DATE_FORMAT = new Array (locales.length);
INVALID_DATE_FORMAT[0] = "{0} n'est pas une date avec un format valide : JJ/MM/AAAA.";
INVALID_DATE_FORMAT[1] = "{0} is not a date with a valid format : dd/MM/yyyy.";

var INVALID_NUMBER_INTERVAL = new Array (locales.length);
INVALID_NUMBER_INTERVAL[0] = "{0} doit être compris entre {1} et {2}.\n";
INVALID_NUMBER_INTERVAL[1] = "{0} must be included between {1} and {2}.\n";

var INVALID_EMAIL_FORMAT = new Array (locales.length);
INVALID_EMAIL_FORMAT[0] = "{0} non valide.";
INVALID_EMAIL_FORMAT[1] = "{0} is not valid.";

var INVALID_PHONE_NUMBER = new Array (locales.length);
INVALID_PHONE_NUMBER[0] = "{0} non valide.";
INVALID_PHONE_NUMBER[1] = "{0} is not valid.";

var NUMBER_MUST_BE_GREATER = new Array (locales.length);
NUMBER_MUST_BE_GREATER[0] = "{0} doit être supérieur ou égal à {1}.";
NUMBER_MUST_BE_GREATER[1] = "{0} must be greater than or equal to {1}.";

var NUMBER_MUST_BE_LESS = new Array (locales.length);
NUMBER_MUST_BE_LESS[0] = "{0} doit être inférieure ou égal à {1}.";
NUMBER_MUST_BE_LESS[1] = "{0} must be less than or equal to {1}.";

var PB_SUPERIOR_LIMIT = new Array (locales.length);
PB_SUPERIOR_LIMIT[0] = "pb Borne Sup si {0} <= à {1}";
PB_SUPERIOR_LIMIT[1] = "pb superior limit if {0} <= to {1}";

var BEGINNING_DATE_GREATER_THAN_END_DATE = new Array (locales.length);
BEGINNING_DATE_GREATER_THAN_END_DATE[0] = "{0} doit être supérieure ou égale &agrave; {1}";
BEGINNING_DATE_GREATER_THAN_END_DATE[1] = "{0} must be greater than or equal to {1}.";

var INVALID_MONTH = new Array (locales.length);
INVALID_MONTH[0] = "Mois doit être compris entre 1 et 12.";
INVALID_MONTH[1] = "Month must be included between 1 and 12.";

var INVALID_DAY = new Array (locales.length);
INVALID_DAY[0] = "Jour doit être compris entre 1 et 31.";
INVALID_DAY[1] = "Day must be included between 1 and 31.";

var MONTH_HAS_NOT_31_DAYS = new Array (locales.length);
MONTH_HAS_NOT_31_DAYS[0] = "Le mois {0} n'a pas 31 jours.";
MONTH_HAS_NOT_31_DAYS[1] = "The month {0} has not 31 days.";

var FEBRUARY_HAS_NOT_XX_DAYS = new Array (locales.length);
FEBRUARY_HAS_NOT_XX_DAYS[0] = "Février {0} n'a pas {1} jours.";
FEBRUARY_HAS_NOT_XX_DAYS[1] = "February has not {0} days.";

var CONFIRM_VALID_MODIF = new Array (locales.length);
CONFIRM_VALID_MODIF[0] = "Des modifications ont été effectuées ! Voulez vous les annuler ?";
CONFIRM_VALID_MODIF[1] = "";

var firstElement = null;

/******************************************************************************/
function initFunction(bActiveGestionModif)
/*
 R?le :
 - changer dynamiquement le style des champs obligatoires des formulaires
	 (en utilisant la classe INPUTOBLIGATOIRE d?finie dans la feuille de style)
 - donner le focus au premier ?l?ment du formulaire (tabindex = 1)
 - affecter la fonction changeChamp a l'?v?nement onChange des ?l?ments des formulaires

parametres :
- bActiveGestionModif : permet d'inhiber le message de confirmation lorsque l'utilisateur clique sur le menu
	Valeurs possibles :
		null ou true ou pas de parametre : Affichage des messages de confirmation activ?
		false                            : Affichage des messages de confirmation inhib?

Utilisation :
Cette fonction est syst?matiquement appel?e au chargement des pages contenant un formulaire.
Elle est appel?e dans la balise BODY :
		 <BODY  onload="initFunction();">
*/
{
	if ((bActiveGestionModif != null) && (!bActiveGestionModif))
	{
		bGestionModifie = false;
	}

	for (i=0; i<window.document.forms.length; i++)
	{
		// La fonction colorForm permet de colorier les champs obligatoires du formulaire
		colorForm(window.document.forms[i], "INPUTOBLIGATOIRE");

		for (j=0; j<window.document.forms[i].length; j++)
		{
			targetElement = window.document.forms[i][j]

			// Recherche du premier element du formulaire
			if (targetElement.getAttribute("tabindex") == 1)
			{
				firstElement = targetElement;
			}
			// Affectation de la fonction changeChamp a l'evenement onChange
			// (cette fonction permet de detecter tout changement dans un formulaire)
			targetElement.onchange = function(){changeChamp(this);};


			// CONSTAT : Lorsque des checkbox d'un formulaire ne sont pas cochees,
			// elles ne sont pas soumises avec le formulaire dans la requete
			// PB : On ne sait pas d?tecter qu'une checkbox a ?t? d?coch?e.
			// Pour repondre a ce probleme, un champ hidden est syst?matiquement associe aux checkbox :
			//
			// A tout element de type checkbox, doit un etre associe un element de type hidden
			// A tout element de type checkbox, doivent etre associees les balises WAFCheckedElement WAFCheckedValue et WAFUnCheckedValue
			// L'element de type hidden doit avoir pour attribut name la valeur de WAFCheckedElement
			// Le code suivant permet de mettre a jour automatiquement le champ hidden  :
			//  - avec la valeur WAFCheckedValue lorsque la checkbox est coch?e
			//  - avec la valeur WAFUnCheckedValue lorsque la checkbox est d?coch?e
			if (targetElement.type == "checkbox")
			{
				CheckedElement = targetElement.getAttribute("WAFCheckedElement");
				CheckedValue = targetElement.getAttribute("WAFCheckedValue");
				UnCheckedValue = targetElement.getAttribute("WAFUnCheckedValue");

				if (targetElement.name != null && targetElement.name != '')
				{
					if (debug)
					alert(ATTRIBUTE_MUST_NOT_HAVE_VALUE[locale]);
				}


				if (CheckedElement  != null && CheckedElement  != "" && CheckedValue  != null && CheckedValue  != "" && UnCheckedValue != null && UnCheckedValue != "" )
				{
					eval('ElementChecked = window.document.forms[i].' +CheckedElement + ';');
					if (ElementChecked == null )
					{
						if (debug)
						alert (genMessage(NO_ELEMENT_ASSOCIATED_TO_CHECKBOX[locale], CheckedElement));
					}
					else
					{
						if (targetElement.value == CheckedValue)
						{
							targetElement.checked=true;
							eval('window.document.forms[i].'+CheckedElement +'.value="'+ CheckedValue +'";');
						}
						if (targetElement.value == UnCheckedValue)
						{
							targetElement.checked=false;
							eval('window.document.forms[i].'+CheckedElement +'.value="'+ UnCheckedValue +'";');
						}
						k = i.toString() ;
						targetElement.onclick = function(){ChangeCheckBoxHiddenElement (this); };
					}
				}
				else
				{
					if (debug)
					alert(NOT_ALL_MANDATORY_ATTRIBUTES_FOR_CHECKBOX[locale]);
				}
			}
			// fin traitement de la checkbox

		}

		// Positionnement sur le premier element du formulaire (tabindex = 1)
		if ( ! (firstElement== null) )
		{
			focusElement(firstElement);
		}
	}
}
/******************************************************************************/
function ChangeCheckBoxHiddenElement (targetElement)
/*
Role : Permet de valoriser les champ hidden associes aux checkbox avec les valeurs
associes aux parametres WAFCheckedValue ou WAFUnCheckedValue

parametres :
- targetElement  : element (de type checkbox) a gerer
*/
{
	CheckedElement = targetElement.getAttribute("WAFCheckedElement");
	CheckedValue = targetElement.getAttribute("WAFCheckedValue");
	UnCheckedValue = targetElement.getAttribute("WAFUnCheckedValue");

	if (targetElement.checked)
	{
		eval('targetElement.form.'+CheckedElement +'.value="'+ CheckedValue +'";');
	}
		else
	{
		eval('targetElement.form.'+CheckedElement +'.value="'+ UnCheckedValue +'";');
	}
}
/******************************************************************************/
function colorForm(frm, className)
/*
Role : colorForm permet de colorier les champs obligatoires du formulaire frm
en changeant son style (changement de la classe)

Parametres :
- frm   : formulaire a colorier
- className : classe associee aux elements obligatoires (definie dans la feuille de style)
*/
{
	var i;
	var j=1;

	for (i=0; i<frm.length; i++)
	{
		targetElement =  frm[i] ;

		obligatoire = targetElement.getAttribute("WAFObligatoire");
		if (obligatoire == "true")
		{
		targetElement.className = className;
		}
		else if (targetElement.className == "INPUTPROBLEME")
		{
		targetElement.className = "";
		}

	}
}
/******************************************************************************/
function manualSubmit(frm)
/*
R?le : Validation et soumission d'un formulaire par script ? partir d'un lien href

parametres :
- frm : r?f?rence sur le formulaire
*/
{
	// D?clenche la validation du formulaire, fonction appell?e par le onSubmit du formulaire
	var isSubmit = frm.onsubmit();
	// Soumet le formulaire si aucune valeur ou true retourn?
	if ((isSubmit) || (null==isSubmit))
	{
		// Soumet le formulaire
		frm.submit();
	}
}/******************************************************************************/
function valideFormulaireGenerique(frm)
/*
R?le : Contr?le de la validit? de la saisie effectu?e sur l'ensemble des ?l?ments d'un formulaire
!! On suppose qu'il n'y a qu'un seul formulaire sur la page !!

Parametres :
- frm   : formulaire a valider

Les contr?les sont effectues, sur le formulaire, ?l?ment par ?l?ment.
Des qu'un probl?me est rencontre, on l'affiche et les contr?les sont arr?t?s.
Un formulaire ne peut ?tre soumis tant que des probl?mes sont d?tect?s.

Retour true si saisie correcte sur tout le formulaire, false sinon

Utilisation :
Cette fonction est syst?matiquement appel?e lors de la soumission d'un formulaire
	(?v?nement onSubmit du formulaire ou onClick du bouton d?clenchant
	la soumission du formulaire)

*/
{
   if (frm == null)
      frm = document.forms[0];

      var i ;
      colorForm(frm, "INPUTOBLIGATOIRE");
	for (i=0; i<frm.length; i++)
	{
		targetElement =  frm[i] ;

		if (!valideChamp(targetElement))
		{
                  //targetElement.className = "INPUTPROBLEME";
                  return false;
		}
	}
	if (debug)  alert(CONTROLS_OK[locale]);
	return true;
}
/******************************************************************************/
function valideChamp(targetElement)
/*
R?le : Validation de la saisie effectu?e sur un champ

parametres :
- targetElement  : Element a controler

Retour true si controles OK, false sinon
*/
{
	var msgErreur = '';

	// Lecture des attributs propres au framework
	// WAFObligatoire : Le champ est obligatoire si WAFObligatoire="true"
	// WAFDescription : Description associee a l'element
	// WAFType 		  : Type de l'element saisie (VARCHAR, FLOAT, INTEGER, DATE)
	WAFObligatoire = targetElement.getAttribute("WAFObligatoire");
	WAFDescription = targetElement.getAttribute("WAFDescription");
	WAFType = targetElement.getAttribute("WAFType");

	// Controle que les champs obligatoires du formulaire sont renseignes
	if ( estControleVide(targetElement) )
	{
		if ( WAFObligatoire == "true" )
		{
			msgErreur = genMessage(MISSING_MANDATORY_FIELD[locale], WAFDescription) ;
			alert(msgErreur);
			focusElement(targetElement);
			return (false);
		}
	}
	else
	{
		if (WAFType == "INTEGER" )
		{
			// Controle que les champs de type ENTIER sont au bon format
			if (!EstControleEntier(targetElement))
			{
				msgErreur = genMessage(FIELD_MUST_BE_AN_INTEGER[locale], WAFDescription);
				alert(msgErreur);
				focusElement(targetElement);
				return (false);
			}
		}
		if (WAFType == "FLOAT" )
		{
			// Controle que les champs de type FLOAT ( r?els, montant ) sont au bon format
			if (!EstControleDecimal(targetElement))
			{
				msgErreur = genMessage(FIELD_MUST_BE_A_DECIMAL[locale], WAFDescription);

				alert(msgErreur);
				focusElement(targetElement);
					return (false);
			}
			else
			{
				// WAFNbDecimal : Nb de decimal associe a un element de type FLOAT WAFType = FLOAT
				WAFNbDecimal = targetElement.getAttribute("WAFNbDecimal");
				if (WAFNbDecimal == null)
				{
				WAFNbDecimal = 2;
				}
				// Formatage du decimal avec le nombre de decimal demandes
				targetElement.value = formatDecimal(targetElement.value, WAFNbDecimal, "");
			}
		}
		if (WAFType == "DATE" )
		{
			if (!isValidDate(targetElement) )
			{
			msgErreur = genMessage(INVALID_DATE_FORMAT[locale], WAFDescription);
			alert(msgErreur);
			focusElement(targetElement);
			return false;
			}
		}

		if (WAFType == "EMAIL" )
		{
			if (!isValidEmailRegex(targetElement) )
			{
			msgErreur = genMessage(INVALID_EMAIL_FORMAT[locale], WAFDescription);
			alert(msgErreur);
			focusElement(targetElement);
			return false;
			}
		}
		if (WAFType == "PHONE" )
		{
			if (!isValidPhoneRegex(targetElement) )
			{
			msgErreur = genMessage(INVALID_PHONE_NUMBER[locale], WAFDescription);
			alert(msgErreur);
			focusElement(targetElement);
			return false;
			}
		}

		if ( (WAFType == "FLOAT" ) || (WAFType == "INTEGER" ) )
		{
			//WAFBorneInf : Borne inferieure des elements de type INTEGER et FLOAT
			//WAFBorneSup : Borne superieure des elements de type INTEGER et FLOAT
			// Controle que les ?ventuelles bornes sup?rieures et inf?rieures sont respect?es
			WAFBorneInf = targetElement.getAttribute("WAFBorneInf");
			WAFBorneSup = targetElement.getAttribute("WAFBorneSup");
			if ( !estValeurVide(WAFBorneInf) || !estValeurVide(WAFBorneSup) )
			{
				if ( !estValeurVide(WAFBorneInf) && !estValeurVide(WAFBorneSup) )
				// Les deux bornes Inf?rieures et Sup?rieures sont renseign?es
				{
					if (!controlBorne(targetElement, WAFBorneInf, WAFBorneSup))
					{
						msgErreur = genMessage (INVALID_NUMBER_INTERVAL[locale], WAFDescription, WAFBorneInf, WAFBorneSup);
						alert(msgErreur);
						focusElement(targetElement);
						return (false);
					}
				}
				else if ( !estValeurVide(WAFBorneInf)  )
				{
					// Seule la borne Inf?rieure est renseignee
					if (!controlBorneInf(targetElement, WAFBorneInf))
					{
						msgErreur = genMessage(NUMBER_MUST_BE_GREATER[locale], WAFDescription, WAFBorneInf);
						alert(msgErreur);
						focusElement(targetElement);
						return (false);
					}
				}
				else
				{
					// Seule la borne Sup?rieure est renseignee
					if (!controlBorneSup(targetElement, WAFBorneSup))
					{
						msgErreur = genMessage (NUMBER_MUST_BE_LESS[locale], WAFDescription, WAFBorneSup);
						alert(msgErreur);
						focusElement(targetElement);
						return (false);
					}
				}
			}
		}	
	}

	return (true);
}
/******************************************************************************/
function controlBorneInf(targetElement, BorneInf)
/*
Role : Verifie qu'un element est superieur ou egal a une valeur
parametres :
- targetElement  : element a controler
- BorneInf       : Borne inferieure

Retour : true si targetElement superieur ou egal a la borne inferieure autorisee
*/
{
var val=parseFloat(targetElement.value);
return (val >= BorneInf);

}
/******************************************************************************/
function controlBorneSup(targetElement, BorneSup)
/*
Role :  Verifie qu'un element est inferieur a une valeur
parametres :
- targetElement  : element a controler
- BorneSup       : Borne superieure
Retour : true si targetElement inferieur ou egal a la borne superieure autorisee
*/
{

var val=parseFloat(targetElement.value);

if (debug) alert(genMessage(PB_SUPERIOR_LIMIT[locale], val, BorneSup));
return (val <= BorneSup);
}
/******************************************************************************/
function controlBorne(targetElement, BorneInf, BorneSup)
/*
 Verifie qu'un element est compris entre les bornes inferieure et superieure autorisees
parametres :
- targetElement  : element a controler
- BorneInf       : Borne inferieure
- BorneSup       : Borne superieure
 Retour : true si targetElement compris entre borne inf et borne sup
*/
{
var val=parseFloat(targetElement.value);
return (val >= BorneInf && val <= BorneSup);
}
/******************************************************************************/
function estControleVide(targetElement)
/*
Role : Verifie qu'un element n'est pas vide (le controle doit implementer la methode value)
parametres :
- targetElement  : element a controler
Retour : true si champ vide, false sinon
*/
{
	return ( estValeurVide(targetElement.value) );
}
/******************************************************************************/
function estValeurVide(valeur)
/*
Role : Verifie qu'une valeur n'est pas vide
parametres :
- valeur  : valeur a controler
Retour : true si valeur vide, false sinon
*/
{
	if (valeur == null)
	{ return (true); }
	else
	{ return ((valeur).replace(/[ ]/g, '') == '');	}
}
/******************************************************************************/
function EstControleEntier(targetElement)
/*
Role : Verifie qu'un element a un contenu de type entier
(le controle doit implementer la methode value)
parametres :
- targetElement  : element a controler
Retour : true si champ vide ou entier, false sinon
*/
{
	return (((targetElement.value).replace(/[0-9-]*/, '') == '') || estControleVide(targetElement) );
}
/******************************************************************************/
function EstControleDecimal(targetElement)
/*
Role : Verifie qu'un controle a un contenu d?cimal
(le controle doit implementer la methode value)
parametres :
- targetElement  : element a controler
Retour : true si champ vide ou numeric, false sinon
*/
{
	if ( carCount(targetElement.value, '.') > 1)
	// On verifie que le decimal contient au plus une virgule et/ou un point
	{
		return (false);
	}
	else
	{
	// On verifie que le decimal ne contient pas d'autres caracteres
	// que des numeriques ou un point
		return (((targetElement.value).replace(/[0-9.-]*/, '') == '') || estControleVide(targetElement) );
	}
}
/******************************************************************************/
function EstControleTelephoneFR(targetElement)
/*
Role : Verifie qu'un element a un contenu de t?l?phone : 99.99.99.99.99
(le controle doit implementer la methode value)
parametres :
- targetElement  : element a controler
Retour : true si champ vide ou entier, false sinon
*/
{
	return (((targetElement.value).replace(/\d\d\.\d\d\.\d\d\.\d\d\.\d\d/, '') == '') || estControleVide(targetElement) );
}
/******************************************************************************/
function focusElement( targetElement)
/*
Role : Donne le focus a l'element passe en parametre s'il est accessible
parametres :
- targetElement  : element a controler
*/
{
	if (!targetElement.disabled )
	{
// D?but correction bug focus() pour IE 5.0 : window perd le focus
		window.focus();
// Fin correction bug focus() pour IE 5.0

		targetElement.focus();
		if (targetElement.type == "text")
		{
			targetElement.select();
		}
	}
}
/******************************************************************************/
function formatDecimal(valeur, nbdecimal,separateur_millier)
/*
Role : formate une valeur avec N decimales apr?s la virgule et un separateur de millier
parametres :
- valeur  : valeur a formater
- decimal : nombre de decimale
- separateur_millier : separateur de milliers
*/
// formate un chiffre avec decimal chiffres apr?s la virgule
{
	valeur = valeur.replace(/[ ]/g, '');
	valeur = valeur.replace(/[,]/, '.');

	var deci=Math.round( Math.pow(10,nbdecimal)*(Math.abs(valeur)-Math.floor(Math.abs(valeur)))) ;
	var val=Math.floor(Math.abs(valeur));

	if ((nbdecimal==0)||(deci==Math.pow(10,nbdecimal))) {val=Math.floor(Math.abs(valeur)); deci=0;}
	var val_format=val+"";
	var nb=val_format.length;
	for (var i=1;i<4;i++) {
		if (val>=Math.pow(10,(3*i))) {
			val_format=val_format.substring(0,nb-(3*i))+separateur_millier+val_format.substring(nb-(3*i));
		}
	}
	if (nbdecimal>0) {
		var decim="";
		for (var j=0;j<(nbdecimal-deci.toString().length);j++) {decim+="0";}
		deci=decim+deci.toString();
		val_format=val_format+"."+deci;
	}
	if (parseFloat(valeur)<0) {val_format="-"+val_format;}

	val_format = val_format.replace(/[,]/, '.');

	return val_format;
}
/******************************************************************************/
function carCount( src, car )
/*
Role  : Compte le nombre de caractere de type car contenu dans une chaine src
parametres :
- src  : chaine sur laquelle porte la recherche
- car  : caractere a rechercher dans la chaine
Retour : Nombre de caractere de type car contenu dans une chaine src
*/
{
	var compt = src.split(car).length - 1;
	{ return compt;}
}
/******************************************************************************/
function isChampDateInferieure ( champ_date_deb, champ_date_fin,option) {
/*
Role : Controle que la date contenu dans un element de type date debut
est inferieur ou egale a la date contenu dans un element de type date fin
parametres :
champ_date_deb : Element contenant la date de debut
champ_date_fin : Element contenant la date de fin

Retour : true si champ_date_deb est <= champ ? date_fin
false sinon
*/
	ok = isValDateInferieure(champ_date_deb.value, champ_date_fin.value)

	if (!ok)
	{
	   if (option != null) {
		WAFDescriptionDateDeb = champ_date_deb.getAttribute("WAFDescription");
		WAFDescriptionDateFin = champ_date_fin.getAttribute("WAFDescription");
		alert(genMessage(BEGINNING_DATE_GREATER_THAN_END_DATE[locale], WAFDescriptionDateDeb, WAFDescriptionDateFin));
	   }

	}

	return ok;
}
/******************************************************************************/
function isValDateInferieure ( date_deb, date_fin) {
/**
Role : Controle qu'une date debut est inferieure ou egale a une date fin
parametres :
date_deb : Valeur de la date de debut
date_fin : Valeur de la date de fin

Retour : true si date_deb est <= champ ? date_fin
false sinon
*/

	ok = true;

	var dd_deb = date_deb.substr(0,2);
	var mm_deb = date_deb.substr(3,2);
	var yy_deb = date_deb.substr(6,4);
	var dd_fin = date_fin.substr(0,2);
	var mm_fin = date_fin.substr(3,2);
	var yy_fin = date_fin.substr(6,4);
	if (yy_deb > yy_fin) ok = false;


	if (ok && (yy_deb == yy_fin) && (mm_deb > mm_fin)) ok = false;

	if (ok && (yy_deb == yy_fin) && (mm_deb == mm_fin) && (dd_deb > dd_fin)) ok = false;

	return ok;
}
/******************************************************************************/
function isValidDate(targetElement)
/*
Role : Controle que la date saisie est correcte
Format acceptes :  JJ/MM/AA   ou JJ/MM/AAAA
On accepte 1 ou 2 caracteres pour JJ ( si 1, complete par 0 )
On accepte 1 ou 2 caracteres pour MM ( si 1, complete par 0 )
On accepte 2 ou 4 caracteres pour AA ( si 2, complete par le siecle courant )

Retour : true si le contenu de targetElement est de type date, false sinon
false sinon
*/

{
	var dateStr = targetElement.value;
	var datePat = /^(\d{1,2})(\/)(\d{1,2})\2(\d{2}|\d{4})$/;

	var matchArray = dateStr.match(datePat); // est ce que le format est correct ?
	if (matchArray == null)
	{
		if (debug)
                {
                  var WAFDescription = targetElement.getAttribute("WAFDescription");
                  alert(genMessage(INVALID_DATE_FORMAT[locale], WAFDescription));
                }

		return false;
	}
	day = matchArray[1];
	month = matchArray[3];
	year = matchArray[4];

	if (day.length == 1)
	{
	day = '0'+ day;
	}
	if (month.length == 1)
	{
	month = '0'+ month;
	}
        /* Ici on d?cide de bloquer la date sur 4 digits */
        /* Si on veut pouvoir autoriser les ann?es sur 2 ou 4 digits il faudra enlever la condition ci-dessous et
           utiliser la 2i?me condition qui compl?te l'ann?e par l'ann?e courante */
	if (year.length == 2)
	{
		return false;
	}

/*	if (year.length == 2)
	{
		y = new Date();
		year = y.getFullYear().toString().substring(0,2) + year;
	}
*/
	if (month < 1 || month > 12)
	{
		if (debug)  alert(BEGINNING_DATE_GREATER_THAN_END_DATE[locale]);
		return false;
	}
	if (day < 1 || day > 31)
	{
		if (debug)  alert(INVALID_DAY[locale]);
		return false;
	}
	if ((month==4 || month==6 || month==9 || month==11) && day==31)
	{
		if (debug)  alert(genMessage(MONTH_HAS_NOT_31_DAYS[locale], month));
		return false;
	}
	if (month == 2) { // Controle pour le mois de fevrier ( Annee bissextile )
		var anneeBissextile = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day > 29 || (day==29 && !anneeBissextile))
		{
			if (debug)  alert(genMessage(FEBRUARY_HAS_NOT_XX_DAYS[locale], day));
			return false;
		}
	}
	targetElement.value=day+'/'+month+'/'+year;

	return true;  // La date saisie est correcte
}


/*********************************************************************************/
/**
*Basic Email Validator
*/
function isValidEmail(email) {
	var vmail = email.value;
    if (vmail==null) {
         return false;
    }
    if (vmail.length==0) {  
        return false;
    }
    if (! allValidChars(vmail)) {  // check to make sure all characters are valid
        return false;
    }
    if (vmail.indexOf("@") < 1) { //  must contain @, and it must not be the first character
        return false;
    } else if (vmail.lastIndexOf(".") <= vmail.indexOf("@")) {  // last dot must be after the @
        return false;
    } else if (vmail.indexOf("@") == vmail.length) {  // @ must not be the last character
        return false;
    } else if (vmail.indexOf("..") >=0) { // two periods in a row is not valid
	return false;
    } else if (vmail.indexOf(".") == vmail.length) {  // . must not be the last character
	return false;
    }
    return true;
}

/*******************************************************************************/
/**
*Advanced Email validator (regex)
*/
function isValidEmailRegex(email){
var vemail = email.value;
var maReg = new RegExp ( "^\\w[\\w+\.\-]*@[\\w\-]+\.\\w[\\w+\.\-]*\\w$", "gi" ) ;
if ( vemail.search( maReg ) == -1 )
	return false;
else
	return true;
}
/*******************************************************************************/
function isValidPhoneRegex(phone){
	 var vphone = phone.value;
     var regex = new RegExp("^(01|02|03|04|05|06|08)[0-9]{8}$", "gi");
     if(regex.test(vphone))
     {
         return true;
     }
     return false;
}

/******************************************************************************/
function changeChamp(targetElement)
/*
R?le : Permet de valoriser la variable bEstModifie a true
indiquant qu'une mise a jour a ete effectuee sur le formulaire en cours.
parametre :
- targetElement  : element sur lequel intervient la modification
*/
{
	bEstModifie = true;
}
/******************************************************************************/
function annuler()
/*
R?le : Cette fonction doit etre appelee lorsque l'utilisateur annule la saisie
sur un formulaire.
Si une modification a eu lieu sur le formulaire, une demande de confirmation est affichee.

retour : true si annulation confirm?e. false sinon.
*/
{
	ok_annuler = true;
	if (bEstModifie && bGestionModifie)
	{
		ok_annuler = confirm(CONFIRM_VALID_MODIF[locale]);
	}
	return 	ok_annuler;
}
/******************************************************************************/
function aideSaisieElement(ptargetElement, psourceColumn)
/* Constructeur d'un element d'aide a la saisie */
{
	this.targetElement = ptargetElement;
	this.sourceColumn  = psourceColumn;
}
/******************************************************************************/
function aideSaisieGenerique(pageAide, tabTargetElement, windowstatus)
/* Lancement de l'aide a la saisie */
{
	if ( (windowstatus == null) || (windowstatus == '' ) )
	{
		// Valorisation de l'affichage par defaut de la fen?tre d'aide a la saisie
		windowstatus = "status:false;dialogWidth:1000px;dialogHeight:500px"
	}
	showModalDialog(pageAide,tabTargetElement,windowstatus);
}
/******************************************************************************/
function returnSelectionAideSaisie(formulaireAide) {
/*
Retour de l'aide a la saisie et valorisation des champs sur la page appelante a partir
du formulaire d'aide a la saisie
*/
	var callerWindowObj = dialogArguments;

	for (i=0; i<callerWindowObj.length; i++)
	{
		callerWindowObj[i].targetElement.value = formulaireAide(callerWindowObj[i].sourceColumn).value;
	}
}
/******************************************************************************/
function colorLigne (theRow, theAction)
/*
Fonction graphique qui permet de surligner d'une certaine couleur
une ligne ("theRow") d'un tableau (balise <tr> .... </tr>).
Les actions sont : 'over','out' et 'click' pour un onmouseover,onmouseout et onClick d'une
balise <tr>.
*/
{
    var theCells = null;
    // couleur par defaut pour fpw, background du body : #E7EFF7
    var theDefaultColor = '#CDE2F7' ;
    // couleur de roll over : #DEF6FF
    var thePointerColor = '#DEF6FF' ;
    // couleur de click quand les projets le demande : #FFCC99
    var theMarkColor = '#FFCC99' ;

    // 1. Pointer and mark feature are disabled or the browser can't get the
    //    row -> exits
    if ((thePointerColor == '' && theMarkColor == '')
        || typeof(theRow.style) == 'undefined') {
        return false;
    }

    // 2. Gets the current row and exits if the browser can't get it
    if (typeof(document.getElementsByTagName) != 'undefined') {
        theCells = theRow.getElementsByTagName('td');
    }
    else if (typeof(theRow.cells) != 'undefined') {
        theCells = theRow.cells;
    }
    else {
        return false;
    }

    // 3. Gets the current color...
    var rowCellsCnt  = theCells.length;
    var domDetect    = null;
    var currentColor = null;
    var newColor     = null;
    // 3.1 ... with DOM compatible browsers except Opera that does not return
    //         valid values with "getAttribute"
    if (typeof(window.opera) == 'undefined'
        && typeof(theCells[0].getAttribute) != 'undefined') {
        currentColor = theCells[0].getAttribute('bgcolor');
        domDetect    = true;
    }
    // 3.2 ... with other browsers
    else {
        currentColor = theCells[0].style.backgroundColor;
        domDetect    = false;
    } // end 3

    // 4. Defines the new color
    // 4.1 Current color is the default one
    if (currentColor == ''
        || currentColor.toLowerCase() == theDefaultColor.toLowerCase()) {
        if (theAction == 'over' && thePointerColor != '') {
            newColor = thePointerColor;
        }
        else if (theAction == 'click' && theMarkColor != '') {
            newColor = theMarkColor;
        }
    }
    // 4.1.2 Current color is the pointer one
    else if (currentColor.toLowerCase() == thePointerColor.toLowerCase()) {
        if (theAction == 'out') {
            newColor = theDefaultColor;
        }
        else if (theAction == 'click' && theMarkColor != '') {
            newColor = theMarkColor;
        }
    }
    // 4.1.3 Current color is the marker one
    else if (currentColor.toLowerCase() == theMarkColor.toLowerCase()) {
        if (theAction == 'click') {
            newColor = (thePointerColor != '')
                     ? thePointerColor
                     : theDefaultColor;
        }
    } // end 4

    // 5. Sets the new color...
    if (newColor) {
        var c = null;
        // 5.1 ... with DOM compatible browsers except Opera
        if (domDetect) {
            for (c = 0; c < rowCellsCnt; c++) {
                theCells[c].setAttribute('bgcolor', newColor, 0);
            } // end for
        }
        // 5.2 ... with other browsers
        else {
            for (c = 0; c < rowCellsCnt; c++) {
                theCells[c].style.backgroundColor = newColor;
            }
        }
    } // end 5

    return true;
}

/******************************************************************************/
function setLocale (pLocale)
/*
R?le :
- changer dynamiquement la langue utilis?e pour les messages JavaScript
- si la langue pass?e en param?tre est inconnue, alors aucune modification est effectu?e

Utilisation :
Cette fonction est syst?matiquement appel?e au chargement des pages.

Param?tres :
- pLocale : chaine texte indiquant la langue ? utiliser (ex : 'fr')
*/
{
	for (i=0 ; i<locales.length ; ++i)
	{
		if (locales[i] == pLocale)
		{
			locale = i;
			break;
		}
	}
}

/******************************************************************************/
function genMessage (message, arg0, arg1, arg2, arg3)
/*
R?le :
- g?n?rer un message texte param?tr?, les param?tres ?tant arg0, arg1, arg2 et arg3.

Utilisation :
Les arguments arg0, arg1, arg2 et arg3 sont facultatifs.
Ils ne doivent ?tre d?finis que si ils sont utiles ? la g?n?ration du message param?tr?
Exemple d appel : genMessage ("Bonjour {0} !", "Fabien");

Param?tres :
- message : message param?tr?
- arg0 : param?tre rempla?ant les occurences de {0} dans 'message'
- arg1 : param?tre rempla?ant les occurences de {1} dans 'message'
- arg2 : param?tre rempla?ant les occurences de {2} dans 'message'
- arg3 : param?tre rempla?ant les occurences de {3} dans 'message'

Retour :
 chaine 'message' avec les occurences de {0}, {1}, {2}, {3} remplac?es
 par les param?tres arg0, arg1, arg2, arg3.
*/
{
	var index, newValue;
	for (i=0 ; i<4 ; ++i)
	{
		index = message.indexOf ('{'+i+'}');
		if (index == -1)
			break;
		else
		{
			eval('newValue = arg' + i + ';');
			do {
				message = message.replace ('{'+i+'}', newValue);
				index = message.indexOf ('{'+i+'}');
			} while (index > -1);
		}
	}

	return message;
}
/******************************************************************************/