/*-----------------------------------------------------------------------------------------
fonction 	: VerifReel
Auteur		: EJN
Date		: 04/02/02
Argument	: valeur
Return		: retourne vrai si valeur est un réel faux sinon

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function CheckDouble(objText)
{
	if (document.all)
	{
		if (objText.value != "")
		{
			if (!VerifReel(objText.value))
			{
				alert("Vous devez saisir un numérique")
				objText.focus()
				objText.select()
			}
			else
			{
				Num = objText.value;
				Num = Num.replace(",",".");
				Num = Num * 100;
				Num = Math.round(Num);
				Num = Num / 100;
				objText.value = Num;
			}
		}
	}
}

function VerifReel(reel) {
	var indexPoint;
	var indexVirgule;
	var reg = /^-?\d+$/
	if (reg.exec(reel)){ return true; }
	else {
		indexVirgule = reel.indexOf(",");
		indexPoint = reel.indexOf(".");
		if((indexPoint == -1) && (indexVirgule == -1)){
			return false;
		}else{
			var regInt = /^\d*$/;
			if(indexPoint != -1){
				var partieG = reel.substring(0,indexPoint);
				var partieD = reel.substring(indexPoint+1,reel.length);
				if ((regInt.exec(partieG)!=null) && (regInt.exec(partieD)!=null)){
					return true;
				}else{
					return false;
				}
			}
			if(indexVirgule != -1){
				var partieG = reel.substring(0,indexVirgule);
				var partieD = reel.substring(indexVirgule+1,reel.length);
				if ((regInt.exec(partieG)!=null) && (regInt.exec(partieD)!=null)){
					return true;
				}else{
					return false;
				}
			}
		}
	}
}
 /*-----------------------------------------------------------------------------------------
fonction 	: verifEmail
Auteur		: SMN
Date		: 21/12/01
Argument	: email : adresse email
Return		: retourne vrai si l'adresse est correcte faux sinon

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifEmail(email) {
   var reg = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;
   return (reg.test(email));
}
 /*-----------------------------------------------------------------------------------------
fonction 	: checkInt
Auteur		: SMN
Date		: 07/01/02
Argument	: numerique
Return		: Vérifie si l'objet texte contient un entier
<
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function checkInt(objText)
{
	if (document.all)
	{
		var reg = /^\d+$/
		if ((!reg.exec(objText.value)) && (objText.value != ""))
		{
			alert("Vous devez saisir un entier");
			objText.focus();
			objText.select();
			return false;
		}
		else
		{
			return true;
		}
	}
}

function checkAnnee(objText)
{
flagAnnee = false;
valeur = objText.value
if (valeur.length <= 4)
{
	if (!isNaN(valeur)) flagAnnee = true
	else flagAnnee = false;
}

if (!flagAnnee)
{
	ns6 = (document.getElementById)?true:false ;
	var datefield = objText;
	if (chkdate(objText) == false)
	{
		if (document.all) datefield.select();
		alert("Le format de date est invalide.");
		datefield.focus()
		return false;
	}
	else
	{
		aDate = objText.value.split("/")
		iAnnee = aDate[2]
		objText.value = iAnnee;
		return true;
	}
}
}
/*-----------------------------------------------------------------------------------------
fonction 	: VerifDate
Auteur		: SMN
Date		: 19/02/01
Argument	:
		  - Du : Date de début (JJ/MM/AAAA)
		  - Au : Date de fin (JJ/MM/AAAA)
Return		: cette fonction compare deux dates et renvoie vrai si Du < Au, Faux sinon;

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function VerifDate(Du,Au) {
if (Du == "" && Au == "") {
	return true;
}
else {
	aDateDu = Du.split("/");
	aDateAu = Au.split("/");
	if (aDateDu.length > 2) {
		if (aDateDu[2].length != 4) {
			return "Form";
		}
	}
	if (aDateAu.length > 2) {
	if (aDateAu[2].length != 4) {
		return "Form";
	}
	}
	DateDu = new Date(aDateDu[2], aDateDu[1] - 1, aDateDu[0])
	DateAu = new Date(aDateAu[2], aDateAu[1] - 1, aDateAu[0])
	if (DateDu < DateAu) {
	  return true;
	}
	else {
	  if (Du == Au) {
		return "Egale";
    		}
	else {
		return false;
 		}
	}
}
}

function popupwindow(UrlForPopUp,height,width,option)
{
	sOptions = "height="+height+",width="+width;
	if (option!="")
		sOptions = sOptions + "," + option;
	datewindow = window.open(UrlForPopUp,'popupwindow',sOptions);
	datewindow.focus();
}

function checkdate(objName) {
ns6 = (document.getElementById)?true:false ;

var datefield = objName;
if (chkdate(objName) == false) {
if (document.all) datefield.select();
alert("Le format de date est invalide.");
datefield.focus()
return false;
}
else {
return true;
   }
}

function chkdate(objName,bNoAlert) {

	var strDatestyle = "EU";  //European date style
	var strDate;
	var strDateArray;
	var strDay;
	var strMonth;
	var strYear;
	var intday;
	var intMonth;
	var intYear;
	var booFound = false;
	var datefield = objName;
	var strSeparatorArray = new Array("-"," ","/",".");
	var intElementNr;
	var err = 0;
	var strMonthArray = new Array(12);
	strMonthArray[0] = "Jan";
	strMonthArray[1] = "Feb";
	strMonthArray[2] = "Mar";
	strMonthArray[3] = "Apr";
	strMonthArray[4] = "May";
	strMonthArray[5] = "Jun";
	strMonthArray[6] = "Jul";
	strMonthArray[7] = "Aug";
	strMonthArray[8] = "Sep";
	strMonthArray[9] = "Oct";
	strMonthArray[10] = "Nov";
	strMonthArray[11] = "Dec";

	if (datefield)
		strDate = datefield.value;
	else
	{
		return true;
	}

	if (strDate.length < 1)
	{
		return true;
	}
	for (intElementNr = 0; intElementNr < strSeparatorArray.length; intElementNr++)
	{
		if (strDate.indexOf(strSeparatorArray[intElementNr]) != -1)
		{
			strDateArray = strDate.split(strSeparatorArray[intElementNr]);
			if (strDateArray.length != 3)
			{
				err = 1;
				booFound = false;
				if(!bNoAlert)
				{
					alert("Le format de date est invalide.");
				}
				return false;
			}
			else
			{
				strDay = strDateArray[0];
				strMonth = strDateArray[1];
				strYear = strDateArray[2];

			}
			booFound = true;
   		}
	}
	if (booFound == false)
	{
		if (strDate.length>5)
		{
			strDay = strDate.substr(0, 2);
			strMonth = strDate.substr(2, 2);
			strYear = strDate.substr(4);

   		}
	}

	// US style
	if (strDatestyle == "US")
	{
		strTemp = strDay;
		strDay = strMonth;
		strMonth = strTemp;
	}
	intday = parseInt(strDay, 10);
	if (isNaN(intday))
	{
		err = 2;
		return false;
	}
	intMonth = parseInt(strMonth, 10);
	if (isNaN(intMonth))
	{
		for (i = 0;i<12;i++)
		{
			if (strMonth.toUpperCase() == strMonthArray[i].toUpperCase())
			{
				intMonth = i+1;
				strMonth = strMonthArray[i];
				i = 12;
   			}
		}
		if (isNaN(intMonth))
		{
			err = 3;
			return false;
   		}
	}
	if (!(isNaN(strYear)) && (strYear.length == 2))
	{
		if (strYear > 30)
			strYear = "19" + strYear;
		else
			strYear = "20" + strYear;
		strYear = Math.floor(strYear)
	}
	intYear = parseInt(strYear, 10);
	if (isNaN(strYear) || strYear.length<4)
	{
		err = 4;
		return false;
	}
	else
	{
		if (intYear<1800)
		{
			return false;
		}
	}
	if (intMonth>12 || intMonth<1)
	{
		err = 5;
		return false;
	}
	if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intday > 31 || intday < 1))
	{
		err = 6;
		return false;
	}
	if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intday > 30 || intday < 1))
	{
		err = 7;
		return false;
	}
	if (intMonth == 2)
	{
		if (intday < 1)
		{
			err = 8;
			return false;
		}
		if (LeapYear(intYear) == true)
		{
			if (intday > 29)
			{
				err = 9;
				return false;
			}
		}
		else
		{
			if (intday > 28)
			{
				err = 10;
				return false;
			}
		}
	}
	// Mise en forme
	strDay = (intday < 10) ? ('0' + intday) : intday;
	strMonth = (intMonth < 10) ? ('0' + intMonth) : intMonth;
	if (strDatestyle == "US")
	{
		datefield.value = strMonthArray[intMonth-1] + " " + strDay +" " + strYear;
	}
	else
	{
		datefield.value = strDay + "/" + strMonth + "/" + strYear;
	}
	return true;
}

function LeapYear(intYear) {
if (intYear % 100 == 0) {
if (intYear % 400 == 0) { return true; }
}
else {
if ((intYear % 4) == 0) { return true; }
}
return false;
}

function doDateCheck(from, to) {
if (Date.parse(from.value) <= Date.parse(to.value)) {
alert("Le format de date est invalide");
}
else {
   }
}

function checkHeure(objName){
	var heureValue = objName.value;
	if((heureValue<0) || (heureValue>=25)){
		objName.select;
		alert("Le format de l'heure est invalide.");
		objName.focus();
		return false;
	}
	else {
		return true;
   }
}

function checkMinute(objName){
	var minuteValue = objName.value;
	if((minuteValue<0) || (minuteValue>=60)){
		objName.select;
		alert("Le format des minutes est invalide.");
		objName.focus();
		return false;
	}
	else {
		return true;
   }
}

function VerifPourcentage(objText)
{
	if (!(objText.value == "")){
		if (!(VerifReel(objText.value))){
			alert("Vous devez saisir un entier !");
			objText.focus();
			objText.select();
		}
		else
		{
			if (objText.value > 100)
			{
				alert("Le pourcentage doit-être inférieur à 100")
				objText.focus();
				objText.select();
			}
			else if (objText.value < 0)
			{
				alert("Le pourcentage doit-être supérieur à 0")
				objText.focus();
				objText.select();
			}
			else
			{
				Nombre = objText.value;
				Nombre = Nombre.replace(",",".");
				Nombre = Nombre * 100;
				Nombre = Math.round(Nombre)
				Nombre = Nombre / 100;
				objText.value = Nombre
			}
		}
	}
}
/*-----------------------------------------------------------------------------------------
fonction 	: haut et bas
Auteur		: SMN
Date		: 16/02/01
Argument	:
		  - Formname (nom du formulaire)
		  - Liste (Nom de la liste)
Return		: cette fonction permet de modifier l'ordre de tri d'une option dans une liste;

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function haut(Liste)
{
	if (Count(Liste) !=0)
	{
		if (Liste.selectedIndex != 0)
		{
  			tempValue = Liste.options[Liste.selectedIndex].value
  			tempText = Liste.options[Liste.selectedIndex].text
  			/*Liste.options[Liste.selectedIndex].text 		= Liste.options[Liste.selectedIndex - 1].text;
  			Liste.options[Liste.selectedIndex].value    	= Liste.options[Liste.selectedIndex - 1].value;
			Liste.options[Liste.selectedIndex - 1].text 	= tempText;
  			Liste.options[Liste.selectedIndex - 1].value 	= tempValue;
  			Liste.options[Liste.selectedIndex - 1].selected = true;*/
  			Liste.options[Liste.selectedIndex] 		= new Option(Liste.options[Liste.selectedIndex - 1].text,Liste.options[Liste.selectedIndex - 1].value,true,true)
  			Liste.options[Liste.selectedIndex - 1] 	= new Option(tempText,tempValue,true,true)
		}
	}
}

function bas(Liste)
{
	if (Count(Liste) != 0)
	{
		if (Liste.selectedIndex != Liste.length - 1)
		{
  			tempValue = Liste.options[Liste.selectedIndex].value
  			tempText  = Liste.options[Liste.selectedIndex].text
  			Liste.options[Liste.selectedIndex] 		= new Option(Liste.options[Liste.selectedIndex + 1].text,Liste.options[Liste.selectedIndex + 1].value,true,true)
  			Liste.options[Liste.selectedIndex + 1] 	= new Option(tempText,tempValue,true,true)
		}
	}
}
/*-----------------------------------------------------------------------------------------
fonction 	: Count
Auteur		: SMN
Date		: 13/02/01
Argument	:
		  - form (nom du formulaire)
		  - List (nom de la liste)
Return		: Le nombre de champ sélectionné dans la liste

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function Count(List)
{
	nb = 0;
	for (k=0;k<List.length;k++)
	{
		if (List.options[k].selected == true)
		{
	  		nb = nb + 1;
		}
	}
	return nb;
}

function MM_findObj(n, d) { // v4.0
	var p, i, x;
	if (!d)
		d = document;
	if ((p = n.indexOf("?")) > 0 && parent.frames.length) {
		d = parent.frames[n.substring(p + 1)].document;
		n = n.substring(0, p);
	}
	if (!(x = d[n]) && d.all)
		x = d.all[n];
	for (i = 0; !x && i < d.forms.length; i++)
		x = d.forms[i][n];
	for (i = 0; !x && d.layers && i < d.layers.length; i++)
		x = MM_findObj(n, d.layers[i].document);
	if (!x && document.getElementById)
		x = document.getElementById(n);
	return x;
}

function MM_showHideLayers() { // v3.0
	var i, p, v, obj, args = MM_showHideLayers.arguments;
	for (i = 0; i < (args.length - 2); i += 3)
		if ((obj = MM_findObj(args[i])) != null) {
			v = args[i + 2];
			if (obj.style) {

				obj = obj.style;
				v = (v == 'show') ? 'visible' : (v = 'hide') ? 'hidden' : v;
			}
			obj.visibility = v;
		}
}

/*-----------------------------------------------------------------------------------------
fonction 	: popupSVG(lnk,valchp,valchpSelFr)
Auteur		: RKR
Date		: 23/01/03
Argument	:
		  - lnk : lien vers la page de sélection géographique
		  - valchp : le champ contenant la liste des départements

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function popupSVG(lnk,valchp,valchpSelFr)
{
	DepValue = valchp.value;
	bTouteLaFrance = valchpSelFr.value;
	lnk = lnk + "&Dep=" + DepValue + "&ttFr=" +  bTouteLaFrance;
	window.open(lnk, "SVG","location=no,menubar=no,status=no,toolbar=no,width=710,height=580");
}

 /*-----------------------------------------------------------------------------------------
fonction 	: verifTel
Auteur		: SMN
Date		: 21/12/01
Argument	: email : adresse email
Return		: retourne vrai si l'adresse est correcte faux sinon

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
		VTS 	06/02/03	message en paramètre
		EJN		17/02/03	Modification de l'expression régulière
		SBS		18/08/03	Modification de l'expression régulière
-----------------------------------------------------------------------------------------*/

function verifTel(Tel)
{
	//var rgTel = /^((([0-9]{2}(\.|\s)){4}[0-9]{2})|([0-9]{10}))$/;
	//var rgTel = /^((([0-9]{2}(\.|\s)){6}[0-9]{2})|(([0-9]{2}(\.|\s)){5}[0-9]{2})|(([0-9]{2}(\.|\s)){4}[0-9]{2})|([0-9]{10})|([0-9](\.|\s)([0-9]{2}(\.|\s)){4}[0-9]{2})|([0-9](\.|\s)([0-9]{2}(\.|\s)){5}[0-9]{2})|([0-9](\.|\s)([0-9]{2}(\.|\s)){6}[0-9]{2}))$/;
		var rgTel = /^((([0-9]{2}(\.|\s)){6}[0-9]{2})|(([0-9]{2}(\.|\s)){5}[0-9]{2})|(([0-9]{2}(\.|\s)){4}[0-9]{2})|([0-9](\.|\s)([0-9]{2}(\.|\s)){4}[0-9]{2})|([0-9](\.|\s)([0-9]{2}(\.|\s)){5}[0-9]{2})|([0-9](\.|\s)([0-9]{2}(\.|\s)){6}[0-9]{2})|([0-9]{10}))$/;
	return (rgTel.exec(Tel))
}

function checkTel(objText,message)
{
	if ((objText.value != "") && (!verifTel(objText.value)))
	{
		alert(message);
		objText.focus();
		objText.select();
		return false;
	}
	return true;
}

 /*-----------------------------------------------------------------------------------------
fonction 	: formateTel
Auteur		: SBS
Date		: 21/12/01
Argument	: 	e -> event (à ignorer)
				input -> nom de l'input concerné
Return		: modifie l'input texte de façon à obtenir un numero dans ce format XX XX XX XX
Appel		: ONKEYUP="javascript:formateTel('',this);"
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
		VTS 	06/02/03	message en paramètre
		EJN		17/02/03	Modification de l'expression régulière
-----------------------------------------------------------------------------------------*/

function formateTel(e,input)
{
	if(navigator.appName == "Netscape")
		{KeyEvent = e.which;}
	else
	{
		// MCH on utilise e s'il a été reçu (dans le cas d'un appel ExtJS)
		if (e != '')
			KeyEvent = e.getKey();
		else
			KeyEvent = event.keyCode;
	}

	if((KeyEvent != 37) && (KeyEvent != 38) && (KeyEvent != 39) && (KeyEvent != 40) && (KeyEvent != 16))
	{
		sVal = input.value;

		er = /[ ]/gi;
		sVal = sVal.replace(er,"");

		isValLength = sVal.length;

		sRetour = "";

		for(i=isValLength - 1;i>=0;i--)
			{
			iNbChiffres = sRetour.length;

			if(iNbChiffres == 2)
				{sRetour = " " + sRetour;}

			if((iNbChiffres > 1) && ((sRetour.charAt(2) == " ")))
				{sRetour = " " + sRetour;}

			sRetour = sVal.charAt(i) + sRetour;
			}

		input.value = sRetour;
	}
}

if(navigator.appName == "Netscape")
	{document.captureEvents(Event.KEYUP);}

/*
 * Fonction : verif2Decimales
 * Auteur 	: JPV
 * Date		: 12/06/2007
 *
 * Paramètres :
 * 		- iNB : Nombre dont on souhaite vérifier le format
 *
 * Valeurs de retour :
 * 		- vrai si le nombre est un nombre réel avec 2 chiffres après la virgule au plus
 *
 */
function verif2Decimales(iNb)
{
	iNb = iNb.replace(".",",");
	var sReg = /^\d{1,}([,]\d{0,2})?$/;
	return sReg.test(iNb);
}

/*-----------------------------------------------------------------------------------------
fonction 	: verifNumber16
Auteur		: EJN
Date		: 12/02/2003
Argument	: iNB : Nombre
Return		: retourne vrai si le nombre est un nombre réel pouvant être placé dans la bdd
				le type du champ dans la bdd etant number(16,5)

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifNumber16(iNb){
	iNb = iNb.replace(".",",");
	var sReg = /^\d{1,11}([,]\d{0,5})?$/;
	return sReg.test(iNb);
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifPourcent
Auteur		: EJN
Date		: 04/03/2003
Argument	: iNB : Nombre
Return		: retourne vrai si le nombre est compris entre 0 et 100

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifPourcent(iNb){
	iNb = iNb.replace(".",",");
	var sReg = /^\d{1,3}([,]\d{0,5})?$/;
	if(sReg.test(iNb)){
		return ((parseFloat(iNb) >= parseFloat(0) && parseFloat(iNb) <= parseFloat(99)) || iNb == 100);
	}else{
		return false;
	}
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifCP
Auteur		: EJN
Date		: 05/03/2003
Argument	: iNB : Nombre
Return		: retourne vrai si la valeur est un code postal comporte 5 chiffres

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifCP(sVal){
	var sReg = /^(\d{5})?$/;
	return sReg.test(sVal);
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifEntier
Auteur		: EJN
Date		: 07/03/2003
Argument	: iNB : Nombre
Return		: retourne vrai si la valeur est un entier et est compatible avec le type
				NUMBER16 en bdd
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifEntier(sVal){
	var sReg = /^(\d{1,11})?$/;
	return sReg.test(sVal);
}

/*-----------------------------------------------------------------------------------------
fonction 	: afficheDonneesDynamiques(url)
Auteur		: MHX
Date		: 13/03/2003
Argument	: Url : addresse du fichier gérant les données dynamiques

-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function afficheDonneesDynamiques(url){
	window.open(url,'donneesDynamiqes','width=500,height=400,resizable=no,scrollbars=yes');
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifTaille
Auteur		: EJN
Date		: 26/03/2003
Argument	: iTaille : taille max et sVal
Return		: retourne vrai si la valeur est de longueur inférieure ou égale à iTaille
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifTaille(iTaille,sVal){
	if(iTaille != ""){
		return (sVal.length <= iTaille);
	}else{
		return true;
	}
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifMin
Auteur		: EJN
Date		: 26/03/2003
Argument	: iMin : valeur minimum
			  iVal : valeur saisie
Return		: retourne vrai si la valeur est supérieure à iMin. Si Min n'est pas renseigné
			alors la fonction retourne vrai
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifMin(iMin,iVal){
	if(iMin != ""){
		return(iMin <= parseFloat(iVal));
	}else{
		return true;
	}
}
/*-----------------------------------------------------------------------------------------
fonction 	: verifMax
Auteur		: EJN
Date		: 26/03/2003
Argument	: iMax : valeur maximum
			  iVal : valeur saisie
Return		: retourne vrai si la valeur est inferieure à iMax. Si iMax n'est pas renseigné
			alors la fonction retourne vrai
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function verifMax(iMax,iVal){
	if(iMax != ""){
		return((iMax-1) >= parseFloat(iVal) || iVal == iMax);
	}else{
		return true;
	}
}

function ouvrePropMod(sUrl)
{
	window.open(sUrl,'_blank','width=600,height=500,resizable=no,scrollbars=yes');
}



/*-----------------------------------------------------------------------------------------
fonction 	: addDaysToDate
Auteur		: dle
Date		: 07/02/2006
Argument	: old_date : date
		  delta_days : nombre de jours à ajouter
Return		: retourne la nouvelle date (old_date + delta_days)
-------------------------------------------------------------------------------------------
Modifications:
	-  Auteur	Date		Commentaires
-----------------------------------------------------------------------------------------*/
function addDaysToDate(old_date, delta_days)
{
	// Date plus plus quelques jours
	var split_date = old_date.split('/');
	// Les mois vont de 0 a 11 donc on enleve 1, cast avec *1
	var new_date = new Date(split_date[2], split_date[1]*1 - 1, split_date[0]*1 + delta_days);
	var new_day = new_date.getDate();
	new_day = ((new_day < 10) ? '0' : '') + new_day;
	// ajoute un zéro devant pour la forme
	var new_month = new_date.getMonth() + 1;
	new_month = ((new_month < 10) ? '0' : '') + new_month;
	// ajoute un zéro devant pour la forme
	var new_year = new_date.getYear();
	new_year = ((new_year < 200) ? 1900 : 0) + new_year;
	// necessaire car IE et FF retourne pas la meme chose
	var new_date_text = new_day + '/' + new_month + '/' + new_year;
	return new_date_text;
}

/*-----------------------------------------------------------------------------------------
fonction 	: suppOption
Auteur		: MCH
Date		: 28/11/08
Arguments	: Liste (Nom de la liste)
Return		: cette fonction permet de supprimer toutes les options sélectionnées dans une liste
-----------------------------------------------------------------------------------------*/
function suppOption(Liste)
{
	for(var i = 0; i < Liste.length; i++){
		if (Liste.options[i].selected == true)
			Liste.options[i] = null;
	}
}


/*-----------------------------------------------------------------------------------------
fonction 	: addParamUrl
Auteur		: MCH
Date		: 28/01/09
Arguments	: sUrl (Url)
			 sParamName (Nom du paramètre)
			 sParamValue (valeur du paramètre

Return		: cette fonction permet d'ajouter un paramètre à une url en vérifiant la présence d'un ? dans l'url.
-----------------------------------------------------------------------------------------*/
function addParamUrl(sUrl, sParamName, sParamValue)
{
	var bTrouve = false;
	// Si le '?' est déjà présent dans l'url, on découpe l'url et on parcours pour voir le paramètre ne s'y trouve pas déjà
	if (sUrl.indexOf('?')!=-1){
		var aTab = sUrl.split('?');
		var sBaseUrl = aTab[0]+'?';
		var sParams = aTab[1];
		var aParams = sParams.split('&');
		var sAncre = '';

		// Pour chaque paramètre KEY=VAL
		for (i = 0; i < (aParams.length); i++){

			// Si le paramètre contient une ancre : '#' (ex : VAL=1#BAS)
			if (aParams[i].indexOf('#') != -1){
				// On extrait le paramètre et on mémorise l'ancre
				var aTabTmp = aParams[i].split('#');
				sCouple = aTabTmp[0];
				sAncre = '#' + aTabTmp[1];
			}
			else
				sCouple = aParams[i];

			var aCouple = sCouple.split('=');
			// Si le paramètre est celui à placer dans l'url
			if (aCouple[0] == sParamName){
				sBaseUrl += aCouple[0]+'='+sParamValue+'&';
				bTrouve = true;
			}
			// N'est pas le même que celui à remplacer
			else{
				sBaseUrl += aCouple[0] + '=' + aCouple[1] + '&';
			}
		}

		// Suppression du dernier '&'
		sBaseUrl = sBaseUrl.substring(0, (sBaseUrl.length -1));

		// Si on a pas trouvé le paramètre dans le parcours de paramètres, on l'ajoute
		if (bTrouve === false){
			sBaseUrl += '&' + sParamName + '=' + sParamValue;
		}

		// Ajout de l'ancre si on en a trouvé une
		if (sAncre != '')
			sBaseUrl += sAncre;

		//fin pour chaque couple KEY=VAL
		return(sBaseUrl);
	}
	else
		return(sUrl + '?' + sParamName + '=' + sParamValue);

}


/*-----------------------------------------------------------------------------------------
fonction 	: removeParamUrl
Auteur		: MCH
Date		: 29/01/09
Arguments	: sUrl (Url)
			 sParamName (Nom du paramètre à supprimer)

Return		: cette fonction permet d'ajouter un paramètre à une url en vérifiant la présence d'un ? dans l'url.
-----------------------------------------------------------------------------------------*/
function removeParamUrl(sUrl, sParamName){
	// Si le '?' est déjà présent dans l'url, on découpe l'url et on parcours pour voir le paramètre ne s'y trouve pas déjà
	if (sUrl.indexOf('?')!=-1){
		var aTab = sUrl.split('?');
		var sBaseUrl = aTab[0]+'?';
		var sParams = aTab[1];
		var aParams = sParams.split('&');

		// Pour chaque paramètre KEY=VAL
		for (i = 0; i < (aParams.length); i++){
			var aCouple = aParams[i].split('=');
			// Si le paramètre est celui à placer dans l'url
			if (aCouple[0] != sParamName){
				sBaseUrl += aCouple[0] + '=' + aCouple[1] + '&';
			}
		}

		// Suppression du dernier '&'
		sBaseUrl = sBaseUrl.substring(0, (sBaseUrl.length -1));

		//fin pour chaque couple KEY=VAL
		return(sBaseUrl);
	}
	else
		return(sUrl);
}


/**
 * Fonction permettant d'agrandir la fenêtre au maximum (- quelques pixels)
 * @author MCH
 * @since 03/02/2009
 * @param	Nombre de pixels en moins sur les bords
 * @return void
 */
function maximizeWindow(nDecal)
{
	var nPixelsBord = (nDecal * 2);
	if(window != null)
	{
		window.moveTo(nDecal,nDecal);
		window.resizeTo(screen.availWidth - nPixelsBord, screen.availHeight - nPixelsBord);
	}
}

/**
 * Fonction permettant d'agrandir la fenêtre au maximum (- quelques pixels)
 * @author MCH
 * @since 03/03/2009
 * @param		string	L'url à modifier
 * @param		string	Le nom de l'ancre à ajouter
 * @return 		string	L'url avec le l'ancre ajoutée
 */
function addAncreUrl(sUrl, sNomAncre){
	// On regarde déjà s'il y a déjà un ancre dans l'url. Si oui, on va la remplacer
	if (sUrl.indexOf('#') != -1){
		var aTab = sUrl.split('#');
		sUrl = aTab[0] + '#' + sNomAncre;
	}
	else
		sUrl += '#' + sNomAncre;

	return(sUrl);
}

/**
 * Teste la validité d'un numéro de SIRET
 * @author MCH
 * @since 06/03/2009
 *
 * @param		string	numero	Le numéro de SIRET à tester
 *
 * @return 		bool	L'url avec le l'ancre ajoutée
 *
 * règle de calcul:
 * 1. on multiplie par un chiffre sur 2
 * 2. on aditionne les 21 chiffres résultants
 * le résultat doit être un multiple de 10
 */
function testSIRET(numero){

	var retour = true;

	if (numero == '')
	{
		retour = true;
	}
	else
	{
		siret = numero;
		siret.replace(" ", "");
		siret.replace("-", "");
		siret.replace(",", "");
		if (siret.length != 14)
		{
			retour = false;
		}
		else
		{
			somme = parseInt(0,10);
			// parcours du numéro
			for (var pos = 0; pos < 14; pos++)
			{
				chiffre  = parseInt(siret.charAt(pos),10);
				if (pos % 2)
				{
					// on additionne
					somme = (somme + chiffre);
				}
				else
				{
					// on mulitplie par 2 puis on additionne les chiffres
					if (chiffre >= 5)
					{
						somme += 1 + (2*chiffre % 10);
					}
					else
					{
						somme += 2*chiffre % 10;
					}
				}
			}
			// multiple de 10
			retour  = (somme % 10 == 0);
		}
	}
	return retour;

}

/**
 * Affiche une ligne de tableau en modifiant les classes CSS vis et unvis
 * @author	MCH
 * @since	19/03/2009
 * @param	string	id	Identifiant de la ligne
 * @return	void
 */
function afficheTR(id){
	var elem = document.getElementById(id);
	if (elem)
	{
		elem.className= "vis";
	}

}


/**
 * Affiche une ligne de tableau en modifiant les classes CSS vis et unvis
 * @author	MCH
 * @since	19/03/2009
 * @param	string	id	Identifiant de la ligne
 * @return	void
 */
function masqueTR(id){
	var elem = document.getElementById(id);
	if (elem)
	{
		elem.className= "unvis";
	}
}


/**
 * Teste une frappe clavier récupérée avec getKey() et test s'il s'agit d'une touche spéciale
 * @author	MCH
 * @since	04/08/2009
 * @param	iKey		Number normalisé correspondant aux constantes de la classe EventObject de Ext
 * @return	boolean		true si touche spéciale, false sinon
 */
function isSpecialKey(iKey)
{
	var i = 0;
	var tabSpecialKeys = new Array();
	tabSpecialKeys[i++] = Ext.EventObject.TAB; 	// Tabulation
	tabSpecialKeys[i++] = Ext.EventObject.SHIFT; // Shift
	tabSpecialKeys[i++] = Ext.EventObject.CTRL; // Ctrl
	tabSpecialKeys[i++] = Ext.EventObject.ALT; // Alt
	tabSpecialKeys[i++] = Ext.EventObject.PAGE_UP; // PgUp
	tabSpecialKeys[i++] = Ext.EventObject.PAGE_DOWN; // PgDn
	tabSpecialKeys[i++] = Ext.EventObject.END; // End
	tabSpecialKeys[i++] = Ext.EventObject.HOME; // Home
	tabSpecialKeys[i++] = Ext.EventObject.LEFT; // Cursor Left
	tabSpecialKeys[i++] = Ext.EventObject.UP; // Cursor Up
	tabSpecialKeys[i++] = Ext.EventObject.RIGHT; // Cursor Right
	tabSpecialKeys[i++] = Ext.EventObject.DOWN; // Cursor Down
	tabSpecialKeys[i++] = Ext.EventObject.INSERT;	// Insert
	tabSpecialKeys[i++] = Ext.EventObject.PRINT_SCREEN;	// Impression écran
	tabSpecialKeys[i++] = Ext.EventObject.F1;
	tabSpecialKeys[i++] = Ext.EventObject.F2;
	tabSpecialKeys[i++] = Ext.EventObject.F3;
	tabSpecialKeys[i++] = Ext.EventObject.F4;
	tabSpecialKeys[i++] = Ext.EventObject.F5;
	tabSpecialKeys[i++] = Ext.EventObject.F6;
	tabSpecialKeys[i++] = Ext.EventObject.F7;
	tabSpecialKeys[i++] = Ext.EventObject.F8;
	tabSpecialKeys[i++] = Ext.EventObject.F9;
	tabSpecialKeys[i++] = Ext.EventObject.F10;
	tabSpecialKeys[i++] = Ext.EventObject.F11;
	tabSpecialKeys[i++] = Ext.EventObject.F12;

	for (i=0; i < tabSpecialKeys.length; i++)
	{
		if (iKey == tabSpecialKeys[i])
			return(true);
	}

}