// ======= afin d'empécher la double soumission d'un formulaire ============
var _isFirstSubmitForm = true; 

function isFirstSubmitForm () {
	if (_isFirstSubmitForm == true) {
		_isFirstSubmitForm = false;
		return true;
	}	
	else
		return false;	
}
// =================

// Fonction permettant de fermer une fenetre sans avoir le message de confirmation :
// "La page web affichée tente de fermer la fenetre voulez vous fermer cette fenetre oui ou non ?"
//
function fermerSansConfirmation() { 
	var obj_window = window.open('', '_self');
	obj_window.opener = window;
	obj_window.focus();
	opener=self;
	self.close(); 
} 


//--------------------------------------------------------------------------------- //
// Pour encoder et décoder une URL													//
//	Exemple : Url.encode($('it_test').value); et Url.decode($('it_test').value);	//
// -------------------------------------------------------------------------------- //

var Url = {

    // public method for url encoding
    encode : function (string) {
        return escape(this._utf8_encode(string));
    },

    // public method for url decoding
    decode : function (string) {
        return this._utf8_decode(unescape(string));
    },

    // private method for UTF-8 encoding
    _utf8_encode : function (string) {
        string = string.replace(/\r\n/g,"\n");
        var utftext = "";

        for (var n = 0; n < string.length; n++) {

            var c = string.charCodeAt(n);

            if (c < 128) {
                utftext += String.fromCharCode(c);
            }
            else if((c > 127) && (c < 2048)) {
                utftext += String.fromCharCode((c >> 6) | 192);
                utftext += String.fromCharCode((c & 63) | 128);
            }
            else {
                utftext += String.fromCharCode((c >> 12) | 224);
                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                utftext += String.fromCharCode((c & 63) | 128);
            }

        }

        return utftext;
    },

    // private method for UTF-8 decoding
    _utf8_decode : function (utftext) {
        var string = "";
        var i = 0;
        var c = c1 = c2 = 0;

        while ( i < utftext.length ) {

            c = utftext.charCodeAt(i);

            if (c < 128) {
                string += String.fromCharCode(c);
                i++;
            }
            else if((c > 191) && (c < 224)) {
                c2 = utftext.charCodeAt(i+1);
                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                i += 2;
            }
            else {
                c2 = utftext.charCodeAt(i+1);
                c3 = utftext.charCodeAt(i+2);
                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                i += 3;
            }

        }

        return string;
    }

}



//------------------------------------------------------------- //
// Ajout de caracteres complementaires a DROITE ou a GAUCHE de la chaine	//
// param 1 : Caractere de complement										//
// param 2 : Taille de la chaine en sortie									//
// ------------------------------------------------------------------------ //

// ------ a gauche ---------
String.prototype.lPad = function(padCar, taille) {
	var temp = this;
	while (temp.length < taille) {
		temp = padCar + temp;
	}
	return temp;
}

// ------- a droite --------
String.prototype.rPad = function(padCar, taille) {
	var temp = this;
	while (temp.length < taille) {
		temp += padCar;
	}
	return temp;
}

//----------------------------------------------------------------- //
// suppression des espaces blancs de par et d'autre d'une chaine	//
// ---------------------------------------------------------------- //
String.prototype.trim = function() {
	return this.replace(/^\s+|\s+$/g,"");
}

// ----- gauche uniquement ----
String.prototype.lTrim = function() {
	return this.replace(/^\s+/,"");
}

// ---- droite uniquement ---
String.prototype.rTrim = function() {
	return this.replace(/\s+$/,"");
}

// ---------- suppression des accents ---------
String.prototype.noAccent = function() {
	temp = this;
	temp = temp.replace(/[àâä]/gi,"a");
  	temp = temp.replace(/[éèêë]/gi,"e");
  	temp = temp.replace(/[îï]/gi,"i");
  	temp = temp.replace(/[ôö]/gi,"o");
  	temp = temp.replace(/[ùûü]/gi,"u");
  	temp = temp.replace(/[ç]/gi,"c");
	return temp;
}


//-------------- teste si le tableau contient une valeur ---------
if ( !Array.prototype.contains ) {
	Array.prototype.contains = function( value ) {
		for( var i=0; i<this.length; i++ ) {
			if ( value == this[i] )
				return true;
		}
		return false;
	}
}

//------------- retourne l'indice de l'item dans le tableau ------
if ( !Array.prototype.getItemIndex ) {
	Array.prototype.getItemIndex = function( value ) {
		for( var i=0; i<this.length; i++ ) {
			if ( value == this[i] ) 
				return i;
		}
		return -1;
	}
}

//------------- supprime 1 élément du tableau à un indice donné
if ( !Array.prototype.removeItem ) {
	Array.prototype.removeItem = function( index ) {
		var tmparr = new Array();
		for (var i=0; i<this.length; i++) 
  			if (i != index) 
  				tmparr[tmparr.length] = this[i];
   		return tmparr;		
	}
}



// =============================================
//	Gestion des validations de contenu, format
// =============================================

// ----> varibles globales pour gestion des messages d'erreur
var global_msgErrorList = "";
var global_errorFieldsMap = new Array(); // A compléter dans votre fichier exple : fieldsMap["nomGroupe"] = '<%=jspuser.getLibelle("NOM")%>';

// Pensez a réinitialiser la liste des erreurs avant chaque appel à votre fonction de validation
function resetMsgErrorList () { 
	global_msgErrorList = "";
}

// renvoie le contenu de global_msgErrorList
function getMsgErrorList() { 
	return global_msgErrorList;
}

// Pour ajouter un champ eronné à la liste
function addErrorFieldsMap (eltId, eltLibelle) {
	global_errorFieldsMap[eltId] = eltLibelle;
}


// fonction de callback à appeller pour mettre en évidence ou pas les erreurs
function hideShowErrors(tabIds, isValid) {

	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) 
	{		
		var currEltId = tabElt[i];		
		if ($(currEltId)) 
		{
			var currClass = $(currEltId).className.rTrim();			
			currClass = currClass.replace(new RegExp(" sffocus\\b"), ""); // ATTENTION !!! la fonction sfFocus ajoute cette classe a tous les input
			
			if (isValid) {	
				if (currClass == "InputText_Error")
					$(currEltId).className = "";
				else
					$(currEltId).className = currClass.replace("_Error", "");
			}
			else {			
				if (currClass == "")
					$(currEltId).className="InputText_Error";
				else if (currClass.indexOf("_Error") == -1)
					$(currEltId).className = currClass + "_Error";
					
				//---> ajout au message d'erreur
				if (global_errorFieldsMap[currEltId] != null)
					add_msgError(global_errorFieldsMap[currEltId]);				
			}
		}
	}
}

function add_msgError(message) {
	global_msgErrorList += "<div style='width:100%;text-align:left; margin-left:40px'>-&nbsp;"+ message + "</div></br>";
}


// Réinitialisation des champs
function hideErrors(tabIds) {
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if ($(tabElt[i]))
		{
			var currClass = $(tabElt[i]).className;
			if (currClass == "InputText_Error")
				$(tabElt[i]).className = "";
			else
				$(tabElt[i]).className = currClass.replace("_Error", "");
		}		
	}
}




//----------------------------------------------------------------------------- //
// Validation d'une chaine de Caracteres, renvoie true si valide false sinon	//
// param 1 : Chaine a valider													//
// param 2 : Listes des Caracteres autorises						        	//
// ---------------------------------------------------------------------------- //
function isValidChar(entry, validChar)
{
	if (validChar=="") return true;
	
	for (var i=0; i<entry.length; i++) {
		if ( validChar.indexOf(entry.charAt(i))==-1 )
			return false;
	} 
	return true;
}

// ------------------------------------------------------ //
// Affiche le message d'erreur dans la div correspondante //
// param 1: La chaine qui a causé l'erreur.				  //
// param 2: L'id de l'objet dans lequel on va écrire.	  //
// param 3: le message d'erreur.				  //
// param 4: Affiche ou efface le message.				  //
// ------------------------------------------------------ //

function showErrorMessage(errorString,idObject,message,showHide)
{
	if(errorString != '')
	{
		if(showHide == 1) $(idObject).innerHTML = message + "["+errorString+"]";
		else $(idObject).innerHTML = " ";
	}
	else
	{
		if(showHide == 1) $(idObject).innerHTML = message;
		else $(idObject).innerHTML = " ";
	}
}

// -------------------------------------------------------------------------- //
// Validation d'une chaine de caractères, renvoie true si valide, false sinon //
// param 1: Chaine à valider.											 	  //
// param 2: tableau des caractères interdits.							 	  //
// -------------------------------------------------------------------------- //

function isValidString(entry, noValid)
{
	if(noValid == "") return -1; // Pas de caractères interdits.
	
	for(var i=0 ; i<noValid.length; i++)
	{
		if(entry.search(noValid[i]) != -1) // Si on trouve la chaine interdite, on appelle la fonction et on retourne faux.
		{
			return noValid[i];
		}
	}
	return -1;
}

// ----------------------------------------------------- //
// Validation du contenu de plusieurs ids.   		     //
// param 1: Tableau des id.				  	 		     //
// param 2: Tableau des caractères interdits. 		     //
// param 3: Fonction à appeller si caractère invalide.   //
// param 4: Id de l'objet ou écrire le message d'erreur. //
// ----------------------------------------------------- //

function ValidString(id, noValid, fncallback,idObject)
{
	var isOk = true;
	for(var i=0 ; i<id.length; i++)
	{
		if(isValidString($(id[i]).value,noValid) != -1)
		{
			fncallback(isValidString($(id[i]).value,noValid),idObject,"Ce champ comporte des caract&egrave;res non valides",1);
		 	isOk = false;
		}
		else fncallback(isValidString($(id[i]).value,noValid),idObject,"",0);
	}
	return isOk;
}

// ------------------------------------------ //
// Validation de l'extension d'un file input. //
// ------------------------------------------ //

function isValidFileInput(entry,extensions)
{
	if(extensions == "") return -1;
	if(entry == 0 || entry == null) return "Champ vide";
	else
	{
		// On découpe le fichier en séparant avec les points.
		var tableau = entry.split(".");
		var taille = tableau.length;
		taille--;
		var isOk = tableau[taille].toLowerCase();
		for(var i=0 ; i<extensions.length ; i++)
		{
			if(tableau[taille].toLowerCase().search(extensions[i]) != -1 )
			{
				isOk = -1;
			}
		}
	}
	return isOk;
}
var _tmpImage;
var _tmpName = '';
var _tmpSize = 0;

// ----------------------------------------------------- //
// Validation de l'extension de plusieurs champs file.   //
// param 1: Tableau des file input à tester.		     //
// param 2: Tableau des extensions autorisées.		     //
// param 3: Fonction à appeller si extension invalide.   //
// param 4: Id de l'objet ou écrire le message d'erreur. //
// ----------------------------------------------------- //

function ValidFileInput(files, extensions, fncallback, idObject)
{
	var isOk = true;
	for(var i=0 ; i<files.length; i++)
	{
		if(isValidFileInput($(files[i]).value,extensions) != -1)
		{
			if(isValidFileInput($(files[i]).value,extensions) == "Champ vide") fncallback(isValidFileInput($(files[i]).value,extensions),idObject,"Vous devez renseigner ce champ",1);
			else fncallback(isValidFileInput($(files[i]).value,extensions),idObject,"Cette extension n'est pas supportée",1);
			isOk = false;
		}
		else fncallback(isValidFileInput($(files[i]).value,extensions),idObject,"",0);
	}
	return isOk;
}


// ------------------------------------------ //
// Il faut lancer cette initialisation sur le on change de l'input de type file//
// ------------------------------------------ //
function initValidFileSize(inputId){
	_tmpImage = document.createElement('img');
	_tmpImage.src = document.getElementById(inputId).value;
}

// ------------------------------------------ //
// Cette fonction valide la taille en fonction d'une taille maximum
// FIXME: trouver un meilleur moyen de tester le navigateur
// ------------------------------------------ //
function isValidFileSize(inputId,max_size) {
	var v_console = '';
	_tmpName = document.getElementById(inputId).value;
	_tmpSize = '';
	
	//Pour IE
	if(navigator.appName == "Microsoft Internet Explorer"){
		//On récupere la taille du fichier
		_tmpSize = _tmpImage.fileSize;
		_tmpName = _tmpName.substr(_tmpName.lastIndexOf("\\")+1,_tmpName.length);
		
	//Pour FF3
	}else if(navigator.userAgent.indexOf('Firefox/3')!=-1){
		//Si on a selectionné un fichier
		if(document.getElementById(inputId).files) {
			_tmpName = document.getElementById(inputId).files.item(0).fileName;
			_tmpSize = document.getElementById(inputId).files.item(0).fileSize;
		}
	//Sinon pas un bon browser... 
	}else{
		_tmpName = _tmpName.substr(_tmpName.lastIndexOf("\\")+1,_tmpName.length);
		_tmpSize = -1;
	}
	return (_tmpSize <= max_size);
};

// ------------------------------------------ //
// Valide la taille des inupt
// ------------------------------------------ //

function ValidFileSize(files, maxSize, fncallback, idObject)
{
	var isOk = true;
	for(var i=0 ; i<files.length; i++)
	{
		if(isValidFileSize(files[i],maxSize))
		{
			fncallback(true,idObject,"",0);
		}
		else {
			//On converti la taille en une string
			var mSize = ''+maxSize/1024/1024;
			mSize = mSize.substr(0,3);
			fncallback("Taille maximum = "+mSize+" Mo",idObject,"Fichier trop volumineux ",1);
			isOk = false;
		}
		
	}
	return isOk;
}



//--------------------------------------------------------------------- //
// Validation d'une adresse email, renvoie true si valide false sinon	//
// param 1 : Chaine a valider								        	//
// FIXME: peu de chances que cela fonctionne avec un .mobi ou un .name //
// ---------------------------------------------------------------------//
function isValidMail(mail_address)
{
	pointfinal = mail_address.lastIndexOf(".");
	extension = mail_address.substring(pointfinal+1, mail_address.length);

	if ( pointfinal == -1 || (extension.length != 2 && extension.length != 3 && extension.length != 4) ) {
		return false;
	}
	
	re_email = /^[_a-zA-Z0-9-]+(\.?[_a-zA-Z0-9-\+]+)*@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*$/;
    return mail_address.match(re_email);
}

//--------------------------------------------------------------//
// Validation d'une date, renvoie true si valide false sinon	//
// param 1 : date a valider								        //
// -------------------------------------------------------------//
function isValidDate(d) {
	//var dateRegEx = /^((((0?[1-9]|[12]\d|3[01])[\.\-\/](0?[13578]|1[02])[\.\-\/]((1[6-9]|[2-9]\d)?\d{2}))|((0?[1-9]|[12]\d|30)[\.\-\/](0?[13456789]|1[012])[\.\-\/]((1[6-9]|[2-9]\d)?\d{2}))|((0?[1-9]|1\d|2[0-8])[\.\-\/]0?2[\.\-\/]((1[6-9]|[2-9]\d)?\d{2}))|(29[\.\-\/]0?2[\.\-\/]((1[6-9]|[2-9]\d)?(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)|00)))|(((0[1-9]|[12]\d|3[01])(0[13578]|1[02])((1[6-9]|[2-9]\d)?\d{2}))|((0[1-9]|[12]\d|30)(0[13456789]|1[012])((1[6-9]|[2-9]\d)?\d{2}))|((0[1-9]|1\d|2[0-8])02((1[6-9]|[2-9]\d)?\d{2}))|(2902((1[6-9]|[2-9]\d)?(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)|00))))$/;
	var dateRegEx = /^((((0?[1-9]|[12]\d|3[01])[\-](0?[13578]|1[02])[\-]((1[6-9]|[2-9]\d)?\d{2}))|((0?[1-9]|[12]\d|30)[\-](0?[13456789]|1[012])[\-]((1[6-9]|[2-9]\d)?\d{2}))|((0?[1-9]|1\d|2[0-8])[\-]0?2[\-]((1[6-9]|[2-9]\d)?\d{2}))|(29[\-]0?2[\-]((1[6-9]|[2-9]\d)?(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)|00)))|(((0[1-9]|[12]\d|3[01])(0[13578]|1[02])((1[6-9]|[2-9]\d)?\d{2}))|((0[1-9]|[12]\d|30)(0[13456789]|1[012])((1[6-9]|[2-9]\d)?\d{2}))|((0[1-9]|1\d|2[0-8])02((1[6-9]|[2-9]\d)?\d{2}))|(2902((1[6-9]|[2-9]\d)?(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00)|00))))$/;
	return d.match(dateRegEx);
} 


//------------------------------------------------------------------------------//
// Validation d'une heure au format HH:mm, renvoie true si valide false sinon	//
// param 1 : heure à valider								        			//
// -----------------------------------------------------------------------------//
function isValidHour(h) {
	var heureRegEx = /^([0-1]?[0-9]|2[0-3]):([0-5][0-9])?$/;
	return h.match(heureRegEx);
}

// permet de lancer une validation sur un champs de type date
function onCheckDate(e, obj) 
{
	if (obj==null || obj=="" || obj.id=="")
		return false;
	
	checkDate($(obj.id), obj.message);
}


// vérifie le format de la date passée en param
// thisdate : correspond au champs de saisie lançant l'évennement
function checkDate(thisdate, msg) 
{
	if (thisdate.value!="")
	{	
		var err = 0;
	 	dateValue = thisdate.value;
	 	
	 	if (dateValue.length != 10) 
	 		err=1;
	 		
	 	tmpMonth = dateValue.substring(3, 5); 	// month
	 	//c = dateValue.substring(2, 3); 		// '/'
	 	tmpDay = dateValue.substring(0, 2); 	// day
	 	//e = dateValue.substring(5, 6); 		// '/'
	 	tmpYear = dateValue.substring(6, 10); 	// year
	 	
	 	if (tmpMonth < 1 || tmpMonth > 12) 
	 		err = 1;
	 	if (tmpDay < 1 || tmpDay > 31) 
	 		err = 1;
	 	if (tmpYear < 1900) 
	 		err = 1;
	 	if (tmpMonth == 4 || tmpMonth == 6 || tmpMonth == 9 || tmpMonth == 11) {
	  		if (tmpDay == 31) 
	  			err = 1;
	 	}
	 	if (tmpMonth == 2) {
	  		var g = parseInt(tmpYear/4);
	  		if (isNaN(g)) {
	   			err = 1;
	  		}
	  		if (tmpDay > 29) 
	  			err = 1;
	  		if (tmpDay == 29 && ((tmpYear/4) != parseInt(tmpYear/4))) 
	  			err=1;
		}
	 	if (err == 1) {
	  		if (msg!="")
	  			alertMessage("'" + thisdate.value + "' " + msg);
	  		thisdate.value = "";
	 	}
	 }
}

//--------------------------------------------------------------------- //
// Validation d'un no de telephone, renvoie true si valide false sinon	//
// param 1 : Chaine a valider								        	//
// ---------------------------------------------------------------------//
function isValidTelNumber(tel_entry)
{
	validTelChar = "0123456789+()-*. ";
	return isValidChar(tel_entry, validTelChar)
}

//------------------------------------------------------------- //
// Validation de la longueur d'un entier, renvoie true si valide false sinon	//
// param 1 : valeur a valider
// param 2 : la longueur de l'entier
// pour ce deuxième paramètre, on peut passer + au lieu de la longueur
// '+' : pour dire au moins un ou plusieurs chiffres
// '4' : pour dire 4 chiffres
// ------------------------------------------------------------ //
function isValidLengthInt(entry,length)
{
	var expression = "^[0-9]{"+length+"}$";
	var pattern = new RegExp(expression,"g");
	if (length == '+')
	{
		var pattern = new RegExp("^[0-9]+$","g");
	}	
   return pattern.test(entry);
}
//------------------------------------------------------------- //
//Validation d'un entier
//------------------------------------------------------------ //
function isValidInt(entry)
{
	var pattern = new RegExp("^[0-9]+$","g");
	return pattern.test(entry);
}
//--------------------------------------------------------------------- //
// Validation d'un alpha-numérique, renvoie true si valide false sinon	//
// param 1 : valeur a valider								    		//
// -------------------------------------------------------------------- //
function isValidAlphaNumeric(entry) {
   var pattern = new RegExp("^[a-zA-Z0-9]+$","g");
   return pattern.test(entry);
}

// ======================================
// Fonctions de validation avec callback
// ======================================


// Permet de verifier les champs en saisie obligatoire et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est errone.
function verifNullOrEmpty(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value!=null && thisElt.value!="") {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}

// Permet de verifier le format des champs adresses mails et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est errone.
function verifMail (tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidMail(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	
	return isOk;
}			

// Permet de verifier le format des champs entier et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifInt(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidInt(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}			

// Permet de verifier le format des champs alpha-numeriques et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifAlphaNumeric(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidAlphaNumeric(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}			

// Permet de verifier le format des champs numeriques et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifNumeric(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || !isNaN(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}

// Permet de verifier le format des champs numeriques et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		@param fncallback fonction de callback pour traiter le champs
// 		@param valueLength 	: la taille max de la valeur numérique (cf BD)
// 		@param decimalLength: la taille max du nombre de décimale (cf BD)
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifDecimal(tabIds, fncallback, valueLength, decimalLength) {

	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			var thisEltOk = true;
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			var virgule = thisElt.value.lastIndexOf(".");
			var partieEntiere = (virgule > 0 ? thisElt.value.substring(0, virgule) : thisElt.value);
			var partieDecimale = (virgule > 0 ? thisElt.value.substring(virgule+1, thisElt.value.length) : "");
	
			if ( !verifNumeric(tabElt[i],fncallback) ){
				thisEltOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		
			if (thisEltOk && (partieEntiere.length < 0 || partieEntiere.length > (valueLength-decimalLength)) ) {
				thisEltOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
					
			if ( thisEltOk && partieDecimale.length > decimalLength){
				thisEltOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
			
			if (thisEltOk == false){
				isOk = false;
			}
		}
	}

	return isOk;
}

// Permet de verifier le format des champs telephoniques et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifTelNumber(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidTelNumber(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}

// Permet de verifier le format des champs date et execute une fonction en retour
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifDate(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidDate(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}




// Permet de vérifier le format des champs heure et exécute une fonction en retour
// 		@param tabIds 		: Identifiant des éléments. Passer une chaine ou un tableau
//		fncallback fonction de callback pour traiter le champs
// 		renvoi false si l'un des champs inclus dans tabIds est non valide.
function verifHour(tabIds, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			if (thisElt.value=="" || isValidHour(thisElt.value)) {
				if (fncallback!="") fncallback(tabElt[i], true);
			}
			else {
				isOk = false;
				if (fncallback!="") fncallback(tabElt[i], false);
			}
		}
	}
	return isOk;
}


// permet de verifier la taille de la saisie 
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		@param max			: taille max de la saisie
//		@param fncallback 	: fonction de callback pour traiter le champs
// 		renvoi false si la saise depasse max, true sinon
function verifLimitSaisie(tabIds, max, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) 
	{
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			
			if (fncallback!="") 
				fncallback(tabElt[i], (thisElt.value.length <= max) );
			if (thisElt.value.length > max)
				isOk = false;
		}
	}
	return isOk;
}

// permet de verifier la taille de la saisie 
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		@param size			: taille de la saisie
//		@param fncallback 	: fonction de callback pour traiter le champs
// 		renvoi false si la saise ne fait pas la taille indiquée, true sinon
function verifLength(tabIds, size, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		if($(tabElt[i])) {
			thisElt = $(tabElt[i]);
			thisElt.value = thisElt.value.trim();
			
			if (fncallback!="") 
				fncallback(tabElt[i], (thisElt.value.length == size) );
			if (thisElt.value.length != size)
				isOk = false;
		}
	}
	return isOk;
}


// Permet de lancer plusieurs vrifications sur un champs ou un tableau de champs
// 		@param tabIds 		: Identifiant des elements. Passer une chaine ou un tableau
//		@param tabFnVerif	: liste des fonctions de vérification à exécuter
//		@param fncallback 	: fonction de callback pour traiter le champs
// 		renvoi false dès que l'une des fonction de vérif renvoi false, true sinon.
// Exple utilisation : verifMulti("codePostal", [verifNullOrEmpty, verifInt], hideShowErrors) ou verifMulti(["dateentree", "datedepart"], [verifNullOrEmpty, verifDate], hideShowErrors)
function verifMulti(tabIds, tabFnVerif, fncallback) {
	var isOk = true;
	var tabElt = tabIds.toString().split(",");
	
	for (var k=0; k < tabElt.length; k++) 
	{	
		for (var i=0; i < tabFnVerif.length; i++) {
			var tempOk = true;
			tempOk = tabFnVerif[i] (tabElt[k], fncallback);
			if (!tempOk) {
				isOk = false; 
				break;
			}
		}
	}
	return isOk;
}

// Permet de tester l'unicité d'un champs au moment de sa saisie
// 		@param nomListe : le nom de la table YUI contenant les infos
//		@param nomZone	: le nom de la zone dans la table YUI
//		@param valeur 	: la valeur renseignée par l'utilisateur sur laquelle porte le test
// 		renvoi false dès que la valeur testée est deja présente dans la table
function verifUnicite(nomListe, nomZone, valeur){
	if ( nomListe != null ){
		var rs = nomListe.getRecordSet();
		var record = null;
		for (i=0;i<rs.getLength();i++){
			record = rs.getRecords()[i];
			if ( record.getData(nomZone) == valeur ){
				return false;
			}				
		}
	}
	return true;
}

// Permet de tester l'unicité d'un champs au moment de sa saisie
// 		@param nomListe : le nom de la table YUI contenant les infos
//		@param nomZone	: le nom de la zone dans la table YUI
//		@param valeur 	: la valeur renseignée par l'utilisateur sur laquelle porte le test
//		@param idRecord	: Id du record correspondant à la valeur en cours de modification
//	ATTENTION : lors de l'appel de cette méthode assurez-vous au préalable que l'ordre des record ne peut change par exemple à cause de tri de colonne
// exemple : verifUniciteWithRecordId(YuiListeObj, 'annee', eltAnnee.value, recId)
function verifUniciteWithRecordId(nomListe, nomZone, valeur, idRecord) {
	var rs = nomListe.getRecordSet();
	var record = null;
	for (i=0; i<rs.getLength(); i++) {
		record = rs.getRecords()[i];
		if (i != idRecord && record.getData(nomZone) == valeur ){
			return false;
		}				
	}
	return true;
}


// ==================================
// Validations evennementielles
//		lancees sur des evenements (a la saisie...) onKeyPress, onBlur, ...
// Bibliotheque a importer : /partage/bibliotheques/yui/build/yahoo-dom-event/yahoo-dom-event.js
// ==================================

// Cette fonction permet de definir une validation evenementielle
// 		@param e : evenement
//		@param obj : tableau de parametres
//			obj doit avoir pour syntaxte : var elts = {id:"nomInput", fnValidate:"verifQqch", fnCallback:"afficherErreurs"};
// 			avec id(obligatoire) = le nom de l'input, fnValidate(obligatoire) = le nom de la fonction de validation a appliquer et fnCallback(facultatif) = le nom de la fonction de retour a executer
//			NB : La structure de obj est fixe si vous ne souhaitez pas de fonction de callaback passer fnCallback:"" sinon cela provoque des erreurs
//						var elts = {id:"textMail2", fnValidate:"verifMail", fnCallback:""};
//
//	Exemple d'utilisation : 
//			var paramValidTel = {id:"tel2", fnValidate:"verifTelNumber", fnCallback:"hideShowErrors"};
//			YAHOO.util.Event.addListener("tel2", "keyup", onValidate, paramValidTel);

function onValidate(e, obj) {
	if (obj==null || obj=="" || obj.id=="" || obj.fnValidate=="")
		return false;
	
	if (obj.fnCallback!="")
		return eval ( obj.fnValidate + "('" + obj.id + "', eval(" + obj.fnCallback + ") )" );
	else
		return eval ( obj.fnValidate + "('" + obj.id + "', '' )" );
}


function onKeydownLimitSaisie(e, obj) {
	if (obj==null || obj=="" || obj.id=="" || obj.max=="")
		return false;
	//alert (e.keyCode);
	// 8, 46 = suppr // 27 = ESC // 35 = fin // 45 = inser // 38->40 = fleches de direction
	if (e.keyCode==8 || e.keyCode==46 || e.keyCode==27 || e.keyCode==35 || e.keyCode==45 || (e.keyCode>=38 && e.keyCode<=40) )
		return true;
	else return ($(obj.id).value.length < obj.max);
}


function getKey(e) {
	return window.event ? window.event.keyCode : e ? e.which : 0;
}


// =========================================
// 			GESTION DES DEVISES
// =========================================

// pour récupérer la devise correspondant au groupeId en fonction du tableau JSon de correspondance
// tabloCorrespondance doit etre au format JSON comme suit : var tab = [{groupeId:1004, devise:'EUR'}, {groupeId:1006, devise:'CHF'}, ... ];
function getDeviseGroupe(grpId, tabloCorrespondance) {			
	var searchDevise = "EUR";
	if ( !isNaN(grpId) && grpId > 0) {
		for (var i=0; i<tabloCorrespondance.length; i++) {
			if (tabloCorrespondance[i].groupeId == grpId) {
				searchDevise = tabloCorrespondance[i].devise;
				break;
			}
		}
	}
	return searchDevise;
}

// retourne le css correspondant à la devise passée en param
// param devise : EUR, CHF, ...
function getDeviseClassName(devise) {
	var devClass = "InputTextEuro";
	if (devise!="") {
		if (devise=="CHF")
			devClass = "InputTextFrancSuisse";
		// Autres devises ici ...
	}
	return devClass;
}

// retourne le symbole correspondant à la devise passée en param
// param devise : EUR, CHF, ...
function getDeviseSymbole(devise) {
	var devSymbole = "&euro;";
	if (devise!="") {
		if (devise=="CHF")
			devSymbole = "Frs.";
		// Autres devises ici ...
	}
	return devSymbole;
}

// pour modifier en masse le CSS de plusieurs zones monétaires
// tabloCorrespondance doit etre au format JSON comme suit : var tab = [{groupeId:1004, devise:'EUR'}, {groupeId:1006, devise:'CHF'}, ... ];
// retourne la devise au format HTML
function onChangeDevise(tabIds, tabloCorrespondance, grpId) {
	var tempDevise = getDeviseGroupe(grpId, tabloCorrespondance);
	var deviseClass = getDeviseClassName(tempDevise);
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		$(tabElt[i]).className = deviseClass;
	}
	return getDeviseSymbole(tempDevise);
}

 // ================== fin gestion devise ==========
		

// ============================================		
// 			 FONCTIONS DE FORMATAGE 		

// fonction  i,delKey,direction
function FormatHeure(e,obj) {
	var valeurKey = eval(obj.delKey);

	//alert (window.event.keyCode);
	var id = $(obj.i);
	if (id.value.length < 5) {
   	//	if (valeurKey != 9) { //tab
   			//if the delete, backspace, shift, are not the keys that caused the keyup event.
    		if (valeurKey != 8 && valeurKey != 46 && valeurKey != 16 && !(valeurKey > 36 && valeurKey < 41)) {
     			var fieldLen = id.value.length;
      			if ((valeurKey >= 48 && valeurKey <= 57) || (valeurKey >= 96 && valeurKey <= 105)) {
       				if (fieldLen == 2 ) {
          				id.value = id.value + ":";
        			}
      			} else {
       				if (obj.direction == "up") {
         				if (id.value.length == 0) {
           					id.value = "";
         				} else {
           					id.value = id.value.substring(0,id.value.length-1);
        				}
       				}
    			}
     			id.focus();
    		}
  	/*	} else {
   			if (obj.direction == "down") {
    			CheckHeure(i);
    		}
   		}
   	*/
	}
}

// ------ formattage de date ------------
function onFormatDate(e, obj) 
{
	if (obj==null || obj=="" || obj.id=="" || obj.event=="")
		return false;
	
	formatDate($(obj.id), getKey(e), obj.event, obj.message);
}


// verification du format date en cours de saisie
// Exemple ds 1 input : onkeyup="FormatDate(this, getKey(event),'up', '<%=jspuser.getLibelle("ERREUR_SAISIE_DATE")%>')"
function formatDate(elt, delKey, keyEvent, msg) {
	/*if (elt.value.length < 10) {
   		if (delKey != 9) { //tab
    		if (delKey != 8 && delKey != 46 && delKey != 16 && !(delKey > 36 && delKey < 41)) { //if the delete, backspace, shift, are not the keys that caused the keyup event.
     			var fieldLen = elt.value.length
      			if ((delKey >= 48 && delKey <= 57) || (delKey >= 96 && delKey <=105)) {
       				if (fieldLen == 2 || fieldLen == 5) {
          				elt.value = elt.value + "-";
        			}
      			} 
      			else {
       				if (keyEvent == "keyup") {
         				if (elt.value.length == 0) {
           					elt.value = ""
         				} 
         				else {
           					elt.value = elt.value.substring(0, elt.value.length-1)
        				}
       				}
    			}
     			elt.focus()
    		}
  		} 
  		else {
   			if (keyEvent == "keydown") {
    			checkDate(elt, msg)
    		}
   		}
 	}*/
 	
 	formatDateWithSep(elt, delKey, keyEvent, msg, "-");
}

// verification du format date en cours de saisie
// Exemple ds 1 input : onkeyup="FormatDate(this, getKey(event),'up', '<%=jspuser.getLibelle("ERREUR_SAISIE_DATE")%>', '/')"
function formatDateWithSep(elt, delKey, keyEvent, msg, sep) {
	if (elt.value.length < 10) {
   		if (delKey != 9) { //tab
    		if (delKey != 8 && delKey != 46 && delKey != 16 && !(delKey > 36 && delKey < 41)) { //if the delete, backspace, shift, are not the keys that caused the keyup event.
     			var fieldLen = elt.value.length
      			if ((delKey >= 48 && delKey <= 57) || (delKey >= 96 && delKey <=105)) {
       				if (fieldLen == 2 || fieldLen == 5) {
          				elt.value = elt.value + sep;
        			}
      			} 
      			else {
       				if (keyEvent == "keyup") {
         				if (elt.value.length == 0) {
           					elt.value = ""
         				} 
         				else {
           					elt.value = elt.value.substring(0, elt.value.length-1)
        				}
       				}
    			}
     			elt.focus()
    		}
  		} 
  		else {
   			if (keyEvent == "keydown") {
    			checkDate(elt, msg);
    		}
   		}
 	}
}



// verification du format date en cours de saisie
// Exemple ds 1 input : onkeyup="FormatDate(this, getKey(event),'up', '<%=jspuser.getLibelle("ERREUR_SAISIE_DATE")%>', '/')"
function formatDateWithSepBis(elt, delKey, keyEvent, msg, sep) {
	if (elt.value.length < 10) {
   		if (delKey != 9) { //tab
    		if (delKey != 8 && delKey != 46 && delKey != 16 && !(delKey > 36 && delKey < 41)) { //if the delete, backspace, shift, are not the keys that caused the keyup event.
     			var fieldLen = elt.value.length
      			if ((delKey >= 48 && delKey <= 57) || (delKey >= 96 && delKey <=105)) {
       				if (fieldLen == 2) {
          				elt.value = elt.value + sep;
        			}
      			} 
      			else {
       				if (keyEvent == "keyup") {
         				if (elt.value.length == 0) {
           					elt.value = ""
         				} 
         				else {
           					elt.value = elt.value.substring(0, elt.value.length-1)
        				}
       				}
    			}
     			elt.focus()
    		}
  		} 
  		else {
   			if (keyEvent == "keydown") {
    			checkDate(elt, msg);
    		}
   		}
 	}
}


// -------------- formattage de numéro tel --------------------
function onFormatTelNumber(e, obj) 
{
	if (obj==null || obj=="" || obj.id=="")
		return false;
	
	formatTelNumber($(obj.id), getKey(e));
}

function formatTelNumber (elt, codekey) 
{
   var valid_chars = "0123456789 .-+/#()";
   
   //if the delete, backspace, shift, are not the keys that caused the keyup event.
   if (codekey!=8 && codekey!=46 && codekey!=16 &&  !(codekey>36 && codekey<41)) 
   { 
       var val = elt.value;
       var taille = val.length;
       var caract = val.substring (taille-1,taille);       
       
       if (valid_chars.indexOf(caract)==-1)
       {
       	    if (taille == 0) elt.value = "";             
            else elt.value = val.substring (0,taille-1);
       }
   }
   elt.focus();
}


// ------------- formate un chiffre avec 'decimal' chiffres apres la virgule et un separateur ---------------
function format(valeur, decimal, separateur) {
	var deci = Math.round(Math.pow(10, decimal) * (Math.abs(valeur) - Math.floor(Math.abs(valeur)))); 
	var val = Math.floor(Math.abs(valeur));
	if ((decimal == 0) || (deci == Math.pow(10,decimal))) {
		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 + val_format.substring(nb - (3*i));
		}
	}
	if (decimal > 0) {
		var decim = ""; 
		for (var j=0; j<(decimal-deci.toString().length); j++) {
			decim+="0";
		}
		deci = decim+deci.toString();
		val_format = val_format + "." + deci;
	}
	if (parseFloat(valeur) < 0) {
		val_format = "-" + val_format;
	}
	return val_format;
}

//		FIN FONCTIONS DE FORMATAGE
// ======================================

//permet de mettre en lecture seule en masse des inputs
//param tabIds = tableau des ids des input ou id unitaire --> tabIds = "monInput" ou tabIds = ["input1", "input2"]
//param true pour desactiver, false pour actactiveriger
function setReadonly(tabIds, isDisabled) {
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		thisElt = $(tabElt[i]);
		if (thisElt != null)
			thisElt.readOnly = isDisabled;
	}
}

// permet de dévalider en masse des inputs
// param tabIds = tableau des ids des input ou id unitaire --> tabIds = "monInput" ou tabIds = ["input1", "input2"]
// param true pour desactiver, false pour actiger
function setDisabled(tabIds, isDisabled) {
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		thisElt = $(tabElt[i]);
		if (thisElt != null)
			thisElt.disabled = isDisabled;
	}
}

// permet d'afficher ou masquer en masse des inputs
// param tabIds = tableau des ids des input ou id unitaire --> tabIds = "monInput" ou tabIds = ["input1", "input2"]
// param isVisible : true pour afficher, false pour masquer
function setVisible(tabIds, isVisible) {
	var tabElt = tabIds.toString().split(",");
	for (var i=0; i < tabElt.length; i++) {
		setVisibleElt(tabElt[i],isVisible);
	}
}
// Permet d'afficher ou cacher un element
// param eleId = id de l'element 
// param isVisible : true pour afficher, false pour masquer
function setVisibleElt(eleId, isVisible){
	var thisElt = $(eleId);
	if (thisElt != null){
		if(isVisible){
			thisElt.style.display="";
			thisElt.style.visibility = "visible";
		}else{
			if( navigator.appName == "Microsoft Internet Explorer"){
				thisElt.style.display="none";
				thisElt.style.visibility = "visible";
			}else{ 
				thisElt.style.display="none";
				thisElt.style.visibility = "collapse";
			}
		}
	}
}

// Permet d'afficher ou cacher un element en fonction de son etat courant
// param eleId = id de l'element 
function swapVisible(eleId){
	var thisElt = $(eleId);
	var visible = true;
	if (thisElt != null){
		if( navigator.appName == "Microsoft Internet Explorer")
			visible = (thisElt.style.display=="none")?true:false;
		else
			visible = (thisElt.style.visibility!="visible")?true:false;		
		setVisibleElt(eleId,visible);
	}
}

// fonction d'annulation
function non() {
	this.cancel();
	return false;
}


// ============================================================
// =================== Création d'un sélecteur ================

function fillSelecteur (idSelect, optionListe, selectedKey) 
{
	var monSelect = document.getElementById(idSelect);
	monSelect.options.length = 0;
	var selected;

	var data = optionListe.toString().split("|");
	for (var i=0; i<data.length; i++) {
		if (data[i] != "") {
			partData = data[i].split("=");
			if (selectedKey == partData[0]) {
				selected = i;
			}
			monSelect.options[monSelect.length] = new Option(partData[1], partData[0]);
		}
	}
	
	//permet de positionner la combo au bon champs
	monSelect.selectedIndex = selected;
}

// Création d'un sélecteur à partir d'un tablea JSON au format : tab = [ {id:1, value:"valeur item"}, {id:2, value:"valeur item"}, ... ]
/*function fillSelecteurFromJSON (idSelect, JSON_liste, selectedKey) 
{
	var monSelect = document.getElementById(idSelect);
	monSelect.options.length = 0;
	var selected;
	var data = JSON_liste;
	if (data != "" && data != null)
	{
		for (var i=0; i < data.length; i++) {
			eltData = data[i];
			if (selectedKey != "" && selectedKey == eltData.id) {
				selected = i;
			}
			monSelect.options[monSelect.length] = new Option(eltData.id, eltData.value);
		}
	}
	
	//permet de positionner la combo au bon champs
	if (selected != null && selected != "") 
		monSelect.selectedIndex = selected;
}*/


/**
	Recopie les items d'un sélecteur à un autre
	selectSource 	= id du sélecteur d'origine
	selectDest		= id du sélecteur à modifier
	selectItemValue	= valeur de l'item à sélectionner
*/
function copyOptionToSelect(selectSource, selectDest, selectItemValue) {
	var indexSelected = 0;
	if ($(selectDest) && $(selectSource)) {
		var monSelectSource = $(selectSource);
		var monSelectDest = $(selectDest);
		monSelectDest.options.length = 0;
		for (var i = 0; i < monSelectSource.options.length; i++) {
			var tempOption = monSelectSource.options[i];
			monSelectDest.options[i] = new Option(tempOption.text, tempOption.value);
			if (selectItemValue == tempOption.value)
				indexSelected = i;
		}
		monSelectDest.selectedIndex = indexSelected;
	}
}

// =======================



// =====================================================================================================
// =============== cette fonction permet de génére une pagination similaire à YUI ======================
/*
	nbTotalRes = nombre total d'enregistrement
	currPage = page courante
	nbPageVisibleMax = nombre max de pages visisbles
	nbResPage			= nombre d'enregistrement par page
	containerName		= containeur ou l'on viendra remplacer le contenu par la pagination générée
	fnCallback			= fonction de retour à exécuter lors du click sur une page ( la signature de cette fonction doit etre : fnCallback(pageNum) )
*/
function generatePaginator(nbTotalRes, currPage, nbPageVisibleMax, nbResPage, containerName, fnCallback)
{
	var container = document.getElementById(containerName);
	
	if (!isNaN(nbTotalRes) && nbTotalRes > 0) 
	{
		var nbPageVisible_div2 = nbPageVisibleMax / 2; // le nombre de pages affichées est : nbPageVisible_div2 * 2 +1
		var nbTotalPage = Math.ceil(nbTotalRes / nbResPage); 	// nombre de pages
				
		var currPageMin = (currPage <= (nbPageVisible_div2 + 1))? 1 : currPage - nbPageVisible_div2;
		var currPageMax = currPage + nbPageVisible_div2;
	
		//on ajuste les pages min et max, car on veut essayer d'avoir autant pages avant et après la page courante
		currPageMax = currPageMax - (currPage - nbPageVisible_div2 - currPageMin);
		currPageMax = (currPageMax > nbTotalPage)? nbTotalPage : currPageMax;
		currPageMin = (currPage <= (nbPageVisible_div2 + 1))? 1: currPageMin - (nbPageVisible_div2 - (currPageMax - currPage));
		currPageMin = (currPageMin < 1)? 1 : currPageMin;
 	
		// ----------------> lien page précédente -----------------
	 	var previous_page = "";
 		if (currPage > 1)
 		{	  				
  			var pagePrec = currPage - 1;
			var pagePrec10 = (currPage - 10 < 1 ? 1 : currPage - 10);
  			
  			previous_page = "<A class=yui-dt-last href='#' onclick=\"" + fnCallback + "(" + pagePrec10 + ") \" >&lt;&lt;</A>   "
  						  + "<A class=yui-dt-last href='#' onclick=\"" + fnCallback + "(" + pagePrec + ") \" >&lt;</A>   ";
 		}
 	
 		// ---------------> pour afficher la page suivante --------
		var next_page = "";
		if (currPage < nbTotalPage)
		{		
			var pageSuiv = currPage + 1;
			var pageSuiv10 = (currPage + 10 > nbTotalPage ? nbTotalPage : currPage + 10);
				
			next_page = "<A class=yui-dt-last href='#' onclick=\"" + fnCallback + "(" + pageSuiv + ") \" >&gt;</A>   "
					  + "<A class=yui-dt-last href='#' onclick=\"" + fnCallback + "(" + pageSuiv10 + ") \" >&gt;&gt;</A>   ";
		}
				
		// ---------------> pour afficher la page courante et les pages proches (+/- 10 pages)
		var noPagesHTML = "";
		for ( var i = currPageMin; i <= currPageMax; i++)	
		{
			if (i > nbTotalPage) 
				break;	
				
			if (i == currPage)	
				noPagesHTML += " <SPAN class=yui-dt-selected>"+ i +"</SPAN> ";
			else
				noPagesHTML += " <A class=yui-dt-page href='#' onclick=\"" + fnCallback + "(" + i + ") \" >"+ i +"</A> ";
		}
		
		
		container.innerHTML = "<SPAN class=yui-dt-paginator id=yui-dt1-paginator1>"
								 + 		"<SPAN id=yui-dt-pagselect1>" + previous_page + noPagesHTML	+ next_page + "</SPAN>"
								 + "</SPAN>";
	}
	else {
		container.innerHTML = "";
	}
}

// =======================


sfFocus = function() {
	var sfEls = document.getElementsByTagName("INPUT");
	for (var i=0; i<sfEls.length; i++) {
		sfEls[i].onfocus=function() {
			this.className+=" sffocus";
		}
		sfEls[i].onblur=function() {
			this.className=this.className.replace(new RegExp(" sffocus\\b"), "");
		}
	}
}
if (window.attachEvent) window.attachEvent("onload", sfFocus);


// ------ quand on clik sur entrée, on soumet le formulaire correspondant à la zone en focus
// en générant un click sur son bouton submit passé en parm
function onEnterSubmitForm (bSubmitName) {
	if (window.event.keyCode == 13)
		$(bSubmitName).click();     
}
//********************************************************
//@return    : ajoute un tooltip sur l'element id
//@param id  : id de l'element recevant le tooltip
//@param msg : message du tooltip
//********************************************************
function addToolTip(id,msg){
	var input = $(id);
	//Creation du tooltip
	var tooltip = document.createElement('div');
	tooltip.className = "tooltip";
	tooltip.innerHTML = "<span></span>"+msg;
	
	//Mise en place
	input.parentNode.appendChild(tooltip);
	var div = document.createElement('div');
	input.parentNode.insertBefore(div,tooltip);
	
	//Listener sur input
	input.onmouseover = function(){
		tooltip.className='tooltip_hover';
	}
	//Listener sur input
	input.onmouseout = function(){
		tooltip.className='tooltip';
	}
	return tooltip;
}

//********************************************************
//@return    : ajoute un tooltip d'une grande largeur sur l'element id
//@param id  : id de l'element recevant le tooltip
//@param msg : message du tooltip
//********************************************************
function addLargeToolTip(id,msg){
    var input = $(id);
    //Creation du tooltip
    var tooltip = document.createElement('div');
    tooltip.className = "tooltip";
    tooltip.innerHTML = "<span></span>"+msg;
    //Mise en place
    input.parentNode.appendChild(tooltip);
    var div = document.createElement('div');
    input.parentNode.insertBefore(div,tooltip);
    
    //Listener sur input
    input.onmouseover = function(){
        tooltip.className='large_tooltip_hover';
    }
    //Listener sur input
    input.onmouseout = function(){
        tooltip.className='tooltip';
    }
    return tooltip;
}

//********************************************************
//@return    : ajoute un tooltip de petite largeur sur l'element id
//@param id  : id de l'element recevant le tooltip
//@param msg : message du tooltip
//********************************************************
function addLittleToolTip(id,msg){
	var clic=0;
	var input = $(id);
	//Creation du tooltip
	var tooltip = document.createElement('div');
	tooltip.className = "tooltip";
	tooltip.innerHTML = "<span></span>"+msg;
	
	//Mise en place
	input.parentNode.appendChild(tooltip);
	var div = document.createElement('div');
	input.parentNode.insertBefore(div,tooltip);
	
	//Listener sur input
	input.onclick = function(){
		if (clic==0){
			tooltip.className='little_tooltip_hover';
			clic=1;
		}
		else{
			tooltip.className='tooltip';
			clic=0;
		}
	}
	
}
//********************************************************
//@return    		: la valeur du radio bouton sélectionné
//@param name		: nom du radio bouton
//********************************************************
function getSelectedRadioValue (name){
	 radiobutton = document.getElementsByName(name);
	 var returnValue = "";
	 if (radiobutton.length == 1){
	 	returnValue = radiobutton.value;
	 } else {
	 	for (i=0;i<radiobutton.length;i++){
	   if (radiobutton[i].checked==true) {
	   	returnValue=radiobutton[i].value;
	   }
	 	}
	 }
	 return returnValue;
	}
	
// Cette fonction permet de verifier que les champs Min< champs Max et champs Min et champs max != indifférent (dans le selecteur)
/*
	eltIdMin = id du champs min
	eltIdMax = id du champs max
	valIndiff = la valeur d'indifférent dans le selecteur
*/
function verifMinMax1(eltIdMin,eltIdMax,valIndiff){
		var min = parseFloat($(eltIdMin).value);
		var max = parseFloat($(eltIdMax).value);
		return !(($(eltIdMin).value!=valIndiff)  && ($(eltIdMax).value !=valIndiff) && (min > max));
	}
	
// Cette fonction permet de verifier que les champs Min< champs Max
/*
	eltIdMin = id du champs min
	eltIdMax = id du champs max
*/
	function verifMinMax(eltIdMin,eltIdMax){
		var min = parseFloat($(eltIdMin).value);
		var max = parseFloat($(eltIdMax).value);
		return !(($(eltIdMin).value!="") && ($(eltIdMax).value!="") && ( min > max));
	} 
	
/**
 * Arrondi la valeur d'un champ de type INPUT à deux chiffres après la virgule
 * @param inputId {String} l'id de l'input à arrondir
 */	
function arrondi(inputId){
	var input = $(inputId);
	if (input != undefined){
		try {
			var v = parseFloat(input.value);
			input.value = Math.round(v * 100 ) / 100
		}catch(e){}
	}
};

/**
 * tronque le texte à la longeur choisie en ajoutant la marque de troncature
 * et encapsule le tout dans un span avec le texte complet en survol
 * laisse le texte en l'état si pas de troncature
 * @param texte
 * @param longueur
 */	
	function texteTronqueAvecSurvol(texte, longueur) {
		if (texte == null) {
			return "";}
    	if (texte.length > longueur) {
    		var buffer = '<span title="';
    		buffer += texte;
    		buffer += '">';
    		buffer += texte.substring(0, longueur);
    		buffer += '[...]';
    		buffer += '</span>';
    		return buffer;
    	} else {
    		return texte;
    	}
    }	

/**
 * tronque le contenu des lignes adresse à la longeur choisie en ajoutant la marque de troncature
 * et encapsule chaque ligne dans un span avec le texte complet en survol
 * laisse le texte en l'état si pas de troncature
 */	
    function formatterAdresseAvecSurvol(ligneAdresse1, ligneAdresse2, codePostal, ville, longueur) {
 		var ligne1 =texteTronqueAvecSurvol(ligneAdresse1, longueur);
		var ligne2= texteTronqueAvecSurvol(ligneAdresse2, longueur);
		var ligne3= texteTronqueAvecSurvol(codePostal +" " + ville, longueur);
		var resultat = ligne1;
			if (ligne2 != "") {
				resultat += '<br>';
				resultat += ligne2;
			}
			resultat += '<br>';
			resultat += ligne3;   
    return resultat;
    }

    /**
     * Méthode retournant la valeur de la case cochée d'un ensemble de boutons radio.
     * @param input Le champ HTML à tester.
     * @return "" si aucune valeur n'est sélectionnée, la valeur sélectionnée sinon.
     */
    function getSelectedRadioValue(input){
    	var returnValue = "";
    	if(document.getElementsByName(input).length == 1)
    		returnValue = $(input).value;
    	else{
    		for(i=0;i<document.getElementsByName(input).length;i++){
    			if(document.getElementsByName(input)[i].checked == true){
    				returnValue = document.getElementsByName(input)[i].value;
    			}
    		}
    	}
    	return returnValue;
    }
    
    function setCheckedRadioValue(input, newValue) {
    	if(!document.getElementsByName(input))
    		return;
    	var radioObj=document.getElementsByName(input);
    	var radioLength = radioObj.length;
    	if(radioLength == undefined) {
    		radioObj.checked = (radioObj.value == newValue.toString());
    		return;
    	}
    	for(var i = 0; i < radioLength; i++) {
    		radioObj[i].checked = false;
    		if(radioObj[i].value == newValue.toString()) {
    			radioObj[i].checked = true;
    		}
    	}
    }

    
    /**
     * Recherche une valeur dans un tableau
     * @deprecated utiliser Array.prototype.contains(value)
     * @param p_val
     * @return
     */
    Array.prototype.in_array = function(p_val) {
        for(var i = 0, l = this.length; i < l; i++) {
            if(this[i] == p_val) {
                rowid = i;
                return true;
            }
        }
        return false;
    }

/**
 * Fonction utilisée pour fixer la taille d'un textarea
 */
    function imposeMaxLength(Object, MaxLen) {
	return (Object.value.length <= MaxLen);
}
  
 /**
  * Retourne un tableau d'element à partir d'un element racine(facultatif)
  */   
document.getElementsByClassName = function(className, elmt)
{
   var selection = new Array();
   var regex = new RegExp("\\b" + className + "\\b");

   // le second argument, facultatif
   if(!elmt)
      elmt = document;
   else if(typeof elmt == "string")
      elmt = document.getElementById(elmt);
   
   // on sélectionne les éléments ayant la bonne classe
   var elmts = elmt.getElementsByTagName("*");
   for(var i=0; i<elmts.length; i++)
      if(regex.test(elmts[i].className))
         selection.push(elmts[i]);

   return selection;
}

/**
 * 
 * permet de vider le champ si la valeur est egal à 0
 */
function viderZoneSiZero(champ){
	value = champ.value;
    if(parseFloat(value)==0) {
        champ.value='';
    }
}

/**
 * Fonction reprenant la fonction array_rand de Php. Renvoit num_req valeurs
 * aleatoires parmi le tableau input.
 * 
 * @param input
 *            le tableau source.
 * @param num_req
 *            le nombre d'elements souhaite.
 * @return les valeurs aleatoires selectionnees.
 * @author Waldo Malqui Silva <http://phpjs.org>
 */
function array_rand(input, num_req) {
	var indexes = [];
	var ticks = num_req || 1;
	if (input instanceof Array) {
		while (true) {
			var rand = Math.floor((Math.random() * input.length));
			if (indexes.length === ticks) {
				break;
			}
			indexes.push(rand);
		}
	} else {
		indexes = null;
	}
	return ((ticks == 1) ? indexes.join() : indexes);
}

/**
 * Genere un mot de passe aleatoire de taille n a partir des characters passes
 * en parametre.
 * 
 * @param n
 *            la longueur souhaitee.
 * @param characters
 *            les caracteres souhaites pour le mot de passe.
 * @return le mot de passe genere ou null si une erreur se produit.
 */
function getRandomPassword(n, characters) {
	if (characters == null || n <= 0)
		return null;
	var randomValues = array_rand(characters, n);
	var password = '';
	for ( var c in randomValues) {
		password += characters[randomValues[c]];
		if (password.length == n)
			return password;
	}
}

/**
 * Change la valeur du champ name avec la valeur value.
 * 
 * @param name
 *            le nom du champ a modifier.
 * @param value
 *            la valeur a affecter.
 * @return {void} pas de retour.
 */
function fillInputWithValue(name, value) {
	if (document.getElementById(name)) {
		document.getElementById(name).value = value;
	}
}