/** Fonction NL2BR **/
function nl2br(str) {
	return replace(str,"<br>","\n");
}

/** Fonction UrlDecode de Php. */
function urldecode(ch) {
   ch = ch.replace(/[+]/g," ");
   return unescape(ch);
}
/**	Effectue la validation d'un numéro de téléphone français.
 *
 *	Cette fonction va effectuer une vérification syntaxique du téléphone français passée en paramètre.
 *
 *	\param num_tel La valeur à valider
 *
 *	\return boolean \c true si le numéro de téléphone est valide, \c false dans le cas contraire.
 *
 */
function validTelephone(num_tel){
	var regex = new RegExp("^(0[1-9])((/[0-9]{2}){4}|(-[0-9]{2}){4}|(\ [0-9]{2}){4}|(\.[0-9]{2}){4}|([0-9]{2}){4})$","i");
	return regex.test(num_tel);
}

/**	Effectue la validation d'une adresse email.
 *
 *	Cette fonction va effectuer une vérification syntaxique de l'adresse email passée en paramètre.
 *
 *	\param email La valeur à valider
 *
 *	\return boolean \c true si l'adresse email est valide, \c false dans le cas contraire.
 *
 */
function validEmail(email){
	var reg = new RegExp("^[a-z]{1}[a-z0-9]*((\.|_|-)[a-z0-9]+)*@[a-z0-9]*((\.|-)[a-z0-9]+)*(\.[a-z]{2,4})$","i");
	return reg.test(email);
}

/**	Effectue la validation d'une adresse url.
 *
 *	Cette fonction va effectuer une vérification syntaxique de l'adresse url passée en paramètre.
 *
 *	Pour être valide, l'url doit comporter le protocole utilisé. C'est à dire que l'url 'www.cyberscope.fr'
 *	ne sera pas considérée comme valide, mais que 'http://www.cyberscope.fr' le sera. Tous les protocoles 
 *	sont acceptés par cette fonction, que ce soit http, ftp, rtsp, etc...
 * 
 *	Les urls contenant un nom d'utilisateur et éventuellement un mot de passe sont également autorisés
 *	par cette fonction.
 *
 *	De la même manière, les url comportant un numéro de port sont également supportées.
 *
 *	\param url La valeur à valider
 *
 *	\return boolean \c true si l'adresse url est valide, \c false dans le cas contraire.
 *
 */
function validUrl(url){
	// Retourne vrai si a est une adresse http valide (http://...)
	var reg = new RegExp( "^[a-z]{3,6}://([a-z0-9\_\.\-]+(:[a-z0-9\_\.\-]+)?@)?[a-z0-9]*((\.|-)[a-z0-9]+)*(\.[a-z]{2,4})", "i" );
	return reg.test(url);
}

/** Supprime les caractères espace, retour chariot et newline de début et fin de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de début et de fin de chaîne.
 *
 */
function trim(str){
	str = str.replace( /^([\s]+)/g, '' ); // Supprime les caractères non-imprimables de début de chaîne
	str = str.replace( /([\s]+)$/g, '' ); // Supprime les caractères non-imprimables de fin de chaîne
	return str;
}

/** Supprime les caractères espace, retour chariot et newline de début de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de début et de fin de chaîne.
 *
 */
function ltrim(str){
	return str.replace( /^([\s]+)/g, '' ); // Supprime les caractères non-imprimables de début de chaîne
}

/** Supprime les caractères espace, retour chariot et newline de fin de chaîne.
 *
 *	\param str Chaîne à traiter
 *
 *	\return str La chaîne originale sans ses espaces de fin de chaîne.
 *
 */
function rtrim(str){
	return str.replace( /([\s]+)$/g, '' ); // Supprime les caractères non-imprimables de fin de chaîne
}

/** Recherche et remplace une occurence presente dans une chaine par une autre
 *
 *	\param oString Chaîne à traiter
 *
 *	\param oStringSearch Chaîne à recherche
 *
 *	\param oStringReplace Chaîne de remplacement
 *
 *	\return oString chaine dont les elements recherche ont ete remplace
 *
 */
/*function replace(oValue,oStringSearch,oStringReplace){
	oString = oValue;
	if((oString.length == 0)||(oStringSearch.length == 0)||(oStringReplace.length == 0)&&(oStringSearch != oStringReplace)){
		while(oString.indexOf(oStringSearch,0) != -1){
			var iPos = oString.indexOf(oStringSearch,0);
			if(iPos == 0){
				if(oString == oStringSearch){
					oString = oStringReplace;
				}
				else{
					oString = oStringReplace + oString.substring(oStringSearch.length,oString.length);
				}
			}
			else{
				if(oString.length == (iPos + oStringSearch.length - 1)){
					oString = oString.substring(0,iPos) + oStringReplace;
				}
				else{
					oString = oString.substring(0,iPos) + oStringReplace + oString.substring(iPos + oStringSearch.length,oString.length);
				}
			}
		}
		return oString;
	}
	else{
		return oString;
	}	
}*/
function replace(str, original, replacement) {
	var result;
	result = "";
	if(str.length){
		while(str.indexOf(original) != -1) {
			if (str.indexOf(original) > 0)
				result = result + str.substring(0, str.indexOf(original)) + replacement;
			else
				result = result + replacement;
			str = str.substring(str.indexOf(original) + original.length, str.length);
		}
		return result + str;
	}else{
		return 	str;
	}
}


/** Complète une chaîne à gauche avec le caractère de complétion.
 *	Si aucun caractère de complétion n'est précisé, la chaîne est complétée avec des espaces
 *
 *	\param str Chaîne à traiter
 *	\param padlength Longueur de la chaîne après traitement.
 *	\param padstr Optionnel, caractère de complétion.
 *
 *	\return str La chaîne de caractère originale complétée à gauche.
 *
 */
function lpad(str,padlength,padstr){
	var l = str.length;
	if( l<padlength ){
		pad = padstr=='undefined' ? ' ' : padstr;
		for( var i=0; i<padlength-l; i++ )
			str = pad + str;
	}
	return str;
}

/** Complète une chaîne à droite avec le caractère de complétion.
 *	Si aucun caractère de complétion n'est précisé, la chaîne est complétée avec des espaces
 *
 *	\param str Chaîne à traiter
 *	\param padlength Longueur de la chaîne après traitement.
 *	\param padstr Optionnel, caractère de complétion.
 *
 *	\return str La chaîne de caractère originale complétée à droite.
 *
 */
function rpad(str,padlength,padstr){
	var l = str.length;
	if( l<padlength ){
		pad = padstr=='undefined' ? ' ' : padstr;
		for( var i=0; i<padlength-l; i++ )
			str += pad;
	}
	return str;
}

/** Vérifie qu'une chaîne décrit un nombre a virgule flottante valide.
 * 	Les séparateurs de décimale acceptés sont la virgule et le point.
 */
function validFloat(ch){
	var reg = new RegExp("^[0-9]+([\.,]{1}[0-9]+)?$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre entier valide.
 *	En plus de sa valeur, le signe peut être précisé. Les signes + et -
 *	présents en début de chaîne sont acceptés. Le signe est optionnel.
 */
function validInt(ch){
	var reg = new RegExp("^(([\+\-]?)([0-9]+))$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre entier non signé valide	
 */
function validUnsignedInt(ch){
	var reg = new RegExp("^(([0-9]+))$");
	return reg.test(ch);
}

function getTimestamp(heure,minute,seconde,jour,mois,annee){
	var dte = new Date();
	if(heure != '')
		dte.setHours(heure);
	else
		dte.setHours(0);
	if(minute != '')
		dte.setMinutes(minute);
	else
		dte.setMinutes(0);
	if(seconde != '')
		dte.setSeconds(seconde);
	else
		dte.setSeconds(0);
	if(jour != '')
		dte.setDate(jour);
	if(mois != '')
		dte.setMonth((Number(mois)-1));
	if(annee != '')
		dte.setFullYear(annee);
	dte.setMilliseconds(0);
	return Math.floor(dte.getTime() / 1000);
	//return dte.getTime();

}


/** Vérifie qu'une chaîne contient une date au format jj/mm/aaaa.
 *
 *	En plus de la validité de son format, sa cohérence est également contrôlée.	
 *
 */
function validDate(ch){
	var reg = new RegExp("^[0-9]{2}/[0-9]{2}/[0-9]{4}$");
	var valid = reg.test(ch);
	if( valid ){
		var date = ch.split('/');
		var day = date[0];
		var month = date[1];
		if(month <= 12 && month > 0 && day > 0){
			if( month<=7 )
				valid = month%2==1 ? day<=31 : day<=30;
			else
				valid = month%2==0 ? day<=31 : day<=30;
			if( valid && month==2 ){
				var year = date[2];
				valid = year%4==0 ? day<=29 : day<=28;
			}
			
		}else
			valid = false;
	}
	return valid;
}

/** Vérifie qu'une chaîne contient une heure au format 24:00[:00]
 *
 *	Cette fonction effectue une vérification du format et de la cohérence de l'heure passée en paramètre.
 *
 */
function validTime(ch){
	var valid = false;
	var reg = new RegExp("^([0-2][0-9]:[0-6][0-9](:[0-6][0-9])?)$");
	var res = reg.exec(ch);
	if( !res ) return false;

	if( parseInt(res[1])<=24 )
		if( parseInt(res[2])<60 )
			if( res.length==2 )
				valid = true;
			else if( res[3]<60 )
				valid = true;

	return valid;
}

/** Vérifie qu'une chaîne contient un code postal valide.
 *	Cette fonction n'est valide que pour les codes postaux français.
 */
function validCodePostal(ch){
	var reg = new RegExp("^((2A|2B|([0-9]{2}))([0-9]{3}))$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un numéro siret valide
 */
function validSiret(ch){
	var reg = new RegExp("^([0-9]{14})$");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un numéro ape-naf valide
 */
function validApe(ch){
	var reg = new RegExp("^(([0-9]{3})[a-z])$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient un nombre hexadécimal
 */
function validHexa(ch){
	var reg = new RegExp("^([0-9A-F]+)$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne contient une couleur au format hexadécimal
 */
function validHexaColor(ch){
	var reg = new RegExp("^([0-9A-F]{6})$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne ne contient que des lettres et des chiffres
 */
function validAlphaNum(ch){
	var reg = new RegExp("^([a-z0-9]+)$","i");
	return reg.test(ch);
}

/** Vérifie qu'une chaîne ne contient que des lettres
 */
function validAlpha(ch){
	var reg = new RegExp("^([a-z]+)$","i");
	return reg.test(ch);
}

/** Permet de créer un mot de passe ne contenant que des lettres et des chiffres.
 *
 *	\param length Optionnel, longueur du mot de passe à générer.
 *
 *	\return string Le mot de passe généré. Ce mot de passe n'est composé que de lettres minuscules et de chiffres.
 *
 */
function createPassword(length){
	if( !length ) length = 6;
	// Crée un mot de passe aléatoire
	var chars = 'abcdefghijklmnopqrstuvwxyz1234567890';
	var pwd = '';
	for( var i=0; i<length; i++ )
		pwd += chars.substr( Math.round( chars.length * Math.random() ), 1 );
	return pwd;
}

function round_decimal( nbr, decimals ){
	nbr = parseFloat(nbr);
	var expo = Math.pow(10,decimals+1);
	nbr = Math.floor( nbr * expo );
	nbr = nbr / expo;
	
	return nbr;
}

// Retourne vrai si une chaîne contient un nombre
function isNumeric(str){
	return str.match( /^-?[0-9]*(\.[0-9]*)?$/ );
}

// Format le nombre
function formatCurrency(nbr,decimals,thousands_sep){

	var formated = new String( nbr );

	if( nbr!='' ){
		formated = formated.replace( / |\xA0/g, '' );
		formated = formated.replace( ',',  '.' );
		if( !isNumeric(formated) )
			return 'Erreur';
		var origin = formated;
		if( decimals && decimals<0 ) decimals = 0;
		origin = formated = round_decimal( formated, decimals ).toString();
		
		if( formated!='' ){
			var entier = parseInt( formated );
			if( !isNaN(entier) ){
				// Insertion du séparateur de milliers
				var strInt = new String( entier );
				var strTemp = '';
				var l = strInt.length;
				var p = 1;
				for( var i=l-1; i>=0; i-- && p++ )
					if( p%3==0 && p!=l )
						strTemp = thousands_sep + strInt.substr( i, 1 ) + strTemp;
					else
						strTemp = strInt.substr( i, 1 ) + strTemp; 
				formated = strTemp;
				
				if( decimals>0 ){
					var p = origin.indexOf( '.' );
					var strFloat = '';
					if( p!=-1 ) {
						strFloat = origin.slice( p+1 );
						if( strFloat.length>decimals )
							strFloat = strFloat.substr(0,decimals);
					}
					strFloat = rpad( strFloat, decimals, '0' );
					formated += ',' + strFloat;
				}
			}
		}	
	}

	return formated;
}




// Rajout des espaces des milliers
// Repositionnne les espaces des millier
function formatNumber(oInt){
	//convertion en chaine
	sInt = "" + oInt;
	sInt = replace(sInt," ","");
	if(sInt.indexOf('.') > -1)
		sInt = sInt.substr(0,Number(sInt.indexOf('.')));
	if(validInt(sInt)){
		if(sInt.length >= 2){
			while((sInt.substring(0,1) == "0")&&(sInt.length >= 2)){
				sInt = sInt.substring(1,sInt.length);
			}
		}
		else{
			if(sInt.substring(0,1) == "0"){
				sInt = sInt.substring(1,sInt.length);
			}
		}
		if(sInt.length > 3){
			var sValue = "";
			var iCmp = 0;
			//alert("sInt.length % 3 : " + (sInt.length % 3));
			//alert("1 : " + sInt);
			if(eval(sInt.length % 3) > 0){
				iCmp = 1;
				sValue = sInt.substring(0,(sInt.length % 3));
			}
			//alert("1 : " + sValue);
			for(var i = 0;((i * 3) + (sInt.length % 3)) < sInt.length; i++){
				sValue += " " + sInt.substring((sInt.length % 3) + (i * 3),(sInt.length % 3) + (i * 3) + 3);
			}
			//supprime si espace de debut
			while (sValue.substring(0,1) == " "){
				sValue = sValue.substring(1,sValue.length);
			}
			return sValue;
		}
		else{
			return sInt;
		}
	}
	else{
		return 0;
	}
}