//--------------------------------------------------------------------
// Nom de la fonction : Activer
// ------------------
// Description :  permet de désactiver ou activer l'objet d'un formulaire.
//
// Paramètres : myForm : nom du formulaire
// ----------   Object : nom de l'objet concerné
//				
// Date de création : 6/05/2002 - Philippe	*/
// --------------------------------------------------------------------
		
	function Activer(visible,myForm,Object)
		{
		var oForm
					
			if (!isNaN(myForm)) {
				eval("oForm=document.forms[" + myForm + "]");
				}
			else{
				eval("oForm=document.forms['" + myForm + "']");
			}
			eval("oForm." + Object +".disabled=" + visible);
		}
//--------------------------------------------------------------------
// Nom de la fonction : Arguments
// ------------------
// Description : prend une châine séparée par des virgules et la met dans
// -----------	 dans un objet qui a une propriété tableau.
//
// Paramètres : sTopic , la liste des chaînes
// ----------   ex : var oTest = new Arguments("Nom","Prenom")
//				Cette fonction rend un objet avec une propriét length pour
//				le nombre d'arguments et un tableau pour les arguments
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function LesArguments(sTopic){
	//il faut compter le nombre d'argument
	this.length=LesArguments.arguments.length;
	for (cpt=0; cpt<=this.length; cpt++) {
		this[cpt]=LesArguments.arguments[cpt];
	}
}


//--------------------------------------------------------------------
// Nom de la fonction : ValiderForm
// ------------------
// Description : Cette fonction se charge de vérifier si tous les champs
// -----------   passés en paramètre sont bien remplis. Elle retourne vrai 
//				 la liste des champs est ok sinon, elle retourne faux, avec
//				 une alerte.
// Paramètres :  MyForm : le nom ou l'indice du formulaire concerné
// ----------	 sListChampsObl : liste des champs obligatoires
//				 sDestination : l'URL de destination du formulaire (optionnel)
//				 Exemple d'appel : ValiderForm(0,'"Nom","Prenom"','Validation.asp')


// Remarque :    Cette fonction ne traîte pas des radiobox, car il suffit
// --------		 d'en cocher une par défault.	
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 31/10/1999 - Philippe
// ----------------------------
// --------------------------------------------------------------------

function ValiderForm(myForm,sListChampsObl,sDestination){
	var bStop
	var bValeur
	var tabArgs //Tableau des arguments
	var oChamps
	var oForm
	var i=0
	var sType
	var lCpt=0
	bStop=false

	if (!isNaN(myForm)) {
		eval("oForm=document.forms[" + myForm + "]");
	}
	else{
		eval("oForm=document.forms['" + myForm + "']");
	};

	eval("tabArgs= new LesArguments(" + sListChampsObl + ")")
	while (i<tabArgs.length){
		eval('oChamps=oForm.' + tabArgs[i]);
		if (typeof(oChamps)!="object") {
			alert("Erreur, le champs " + tabArgs[i] + " est inconnu");
			return;
		}
		sType=oChamps.type
		if (sType==null){//Il existe plusieurs champs de même nom (Radio ou checkbox)
			
			for(j=0;j<oForm.length;j++){
				if (oForm.elements[j].name==tabArgs[i]){//c'est le bon
					sType=oForm.elements[j].type;
				}
				
			}
		}
		if ((sType=="text" || sType=="textarea" || sType=="file") && oChamps.value==""){
			
			alert("Vous devez renseigner ce champ.");oChamps.focus();return false;
		}

		if (sType=="select-one" && oChamps.selectedIndex==	0){
			alert("Vous devez sélectionner un élément dans la cette liste.");oChamps.focus();return false;
		}
		if (sType=="select-multiple" && oChamps.selectedIndex==	0){
			alert("Vous devez sélectionner un élément dans la cette liste.");oChamps.focus();return false;		}
		bValeur=false
		if (sType=="checkbox"){
			for(j=0;j<oForm.length;j++){
				if (oForm.elements[j].name==tabArgs[i]){//c'est le bon
					if (oForm.elements[j].checked) {
						bValeur=true;}
					lCpt=j
				}
			}
			if (!bValeur) {
				alert("Vous devez cocher une des cases.");oForm.elements[lCpt].focus();return false;
			}
		}
		i++
	}
	if (sDestination != null)
		{
		oForm.action = sDestination;
		}
	oForm.submit();
	return true;		
}

//--------------------------------------------------------------------
// Nom de la fonction : ValiderFormConsult
// ------------------
// Description : Cette fonction de charge de vérifier si tous les champs des pages
// ----------	 de consultation passés en paramètre sont bien remplis. Elle retourne vrai si
//				 la liste des champs est ok sinon, elle retourne faux, avec
//				 une alerte.
// Paramètres :  MyForm : le nom ou l'indice du formulaire concerné
// ----------	 sListChampsObl : liste des champs obligatoires
//				 sDestination : l'URL de destination du formulaire (optionnel)
//				 Exemple d'appel : ValiderForm(0,'"Nom","Prenom"','Validation.asp')


// Remarque :    Cette fonction ne traîte pas des radiobox, car il suffit
// --------		 d'en cocher une par défault.	
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 31/10/1999 - Philippe
// ----------------------------
// --------------------------------------------------------------------

function ValiderFormConsult(myForm,sListChampsObl,sDestination){
	var bStop
	var bValeur
	var tabArgs //Tableau des arguments
	var oChamps
	var i=0
	var sType
	var lCpt=0
	bStop=false
	eval("tabArgs= new LesArguments(" + sListChampsObl + ")")
	while (i<tabArgs.length){
		eval('oChamps=document.' + myForm + '.' + tabArgs[i])
		if (typeof(oChamps)!="object") {
			alert("Erreur, le champs " + tabArgs[i] + " est inconnu");
			return;
		}
		sType=oChamps.type
		if (sType==null){//Il existe plusieurs champs de même nom (Radio ou checkbox)
			for(j=0;j<document.forms[myForm].length;j++){
				if (document.forms[myForm].elements[j].name==tabArgs[i]){//c'est le bon
					sType=document.forms[myForm].elements[j].type;
				}
			}
		}
		if ((sType=="text" || sType=="textarea") && oChamps.value==""){
			alert("Vous devez renseigner ce champ.");oChamps.focus();return;
		}

		if (sType=="select-one" && oChamps.selectedIndex==	0){
			alert("Vous devez sélectionner un élément dans la cette liste.");oChamps.focus();return;
		}
		if (sType=="select-multiple" && oChamps.selectedIndex==	0){
			alert("Vous devez sélectionner un élément dans la cette liste.");oChamps.focus();return ;		}
		bValeur=false
		if (sType=="checkbox"){
			for(j=0;j<document.forms[myForm].length;j++){
				if (document.forms[myForm].elements[j].name==tabArgs[i]){//c'est le bon
					if (document.forms[myForm].elements[j].checked) {
						bValeur=true;}
					lCpt=j
				}
			}
			if (!bValeur) {
				alert("Vous devez cocher une des cases.");document.forms[myForm].elements[lCpt].focus();return;
			}
		}
		i++
	}
	if (sDestination != null)
		{
		document.forms[myForm].action = sDestination;
		}
	document.forms[myForm].submit();
	return true;		
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierType
// ------------------
// Description : Cette fonction se charge de vérifier le type d'un champs
// -----------	 de formulaire et de le corriger si besoin et quand c'est 
//				 possible.
// Paramètres :	 oChamps		le champs du formulaire
// ----------	 sType			le type de champs (Date, Entier,Reel,Telephone,Email,Chaine)  
//				 sListArguments	liste d'arguments passés selon le type de champs
//			ex : VerifierType(DateDeb,"Date",true)
//				 VerifierType(Prix,"Reel",false,"0,1000,2")
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierType(oChamps,sType,sListArguments){
	if (sType=="Date") return completerDate(oChamps); //VerifierDate(oChamps,sListLesArguments);
	if (sType=="Entier") return VerifierEntier(oChamps,sListArguments);
	if (sType=="Reel") return VerifierReel(oChamps,sListArguments);
	if (sType=="Tel") return VerifierTel(oChamps);
	if (sType=="Siren") return VerifierSiren(oChamps);
	if (sType=="Siret") return VerifierSiret(oChamps);
	if (sType=="Email") return VerifierEmail(oChamps);
	if (sType=="Chaine") return VerifierChaine(oChamps,sListArguments);
	if (sType=="Heure") return VerifierHeure(oChamps);
	if (sType=="Millier") return VerifierMillier(oChamps);
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierDate
// ------------------
// Description : fonction qui vérifie le type d'une date
// -----------
//
// Paramètres : oChamps
// ----------	sFormat : "Local" pour format france et "Us" pour format us
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierDate(oChamps,sFormat){
	var str
	var verifier=true
	if (oChamps.type!="text"){
		alert("Une erreur s'est produite. Le champs " + oChamps.name + "n'est pas de type text.");return false;
	}
	if (oChamps.value=="") return;
	str=oChamps.value
	dArray=str.split("/");
	if (dArray.length!=3) verifier=false
	else {
		dArray[0]=Str2Int(dArray[0]);
		dArray[1]=Str2Int(dArray[1])-1;
		dArray[2]=Str2Int(dArray[2]);
		if (dArray[2]<50) dArray[2]+=2000;
		if (dArray[2]<100) dArray[2]+=1900;
			if (oChamps!=null&&sFormat=="Local") {
				oChamps.value=Int2Str(dArray[0],2)+"/"+Int2Str(1+dArray[1],2)+"/"+dArray[2];
			}
			if (oChamps!=null&&sFormat=="Us") {
				oChamps.value=Int2Str(dArray[1],2)+"/"+Int2Str(1+dArray[0],2)+"/"+dArray[2];
			}
		dt=new Date(dArray[2], dArray[1], dArray[0]);
		if (sFormat=="Local" && (dt.getMonth()!=dArray[1] || dt.getDate()!=dArray[0]||!verifier)) {verifier=false;}
		if (sFormat=="Us" && (dt.getMonth()!=dArray[0] || dt.getDate()!=dArray[1]||!verifier)) verifier=false;
		if (dt.getYear()==dArray[2]&& verifier) verifier=true;
		if (1900+dt.getYear()==dArray[2]&&verifier) verifier=true;
	}
	if (!verifier) {
		alert("Le format de la date n'est pas correct.");
		oChamps.value="";
		oChamps.select();
		oChamps.focus();
	}

	return verifier
}


//--------------------------------------------------------------------
// Nom de la fonction : VerifierEntier
// ------------------
// Description : fonction qui vérifie le type d'un entier
// -----------
//
// Paramètres : oChamps
// ----------   lMax (borne maxi) et lMin (borne mini) =>optionnel
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierEntier(oChamps,sBornes){

	var verifier=true
	var lMin, lMax, oTest
	var numero=oChamps.value;
	str="";
	count=numero.length;
	if (count<=0) verifier=false;
	
	while (--count>=0) {
		c=numero.charAt(count);
		if (c<"0" || c>"9") numero=numero.substring(0, count) + numero.substring(count+1, numero.length);
	}
	for (count=0; count<numero.length; count++) {
		
		str+=numero.charAt(count);
	}
	numero=str;
	oChamps.value = numero;
	if (sBornes!=""){
		oTest = new Array()
		oTest = sBornes.split(",")
		lMin=Str2Int(oTest[0])
		lMax=Str2Int(oTest[1])
		if (numero<lMin || numero>lMax) {
			alert("Valeur entière erronée. Elle doit être comprise entre " + lMin + " et " + lMax);
			oChamps.value="";
			oChamps.focus();
			verifier=false
		}
	}
	return verifier;
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierReel
// ------------------
// Description : vérifier si le champs est bien un réel
// -----------
//
// Paramètres : oChamps
// ----------	rMin (le min), rMax (le max), sDigit (nombre de chiffre après la virgule)(optionnel)
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierReel(oChamps,sBornes){
	var verifier=true
	var dValue,sValue
	var sStr=""
	var count
	var exp
	sValue=oChamps.value
	count=sValue.length
	if (count<=0) return sStr;
	while (--count>=0) {
		c=sValue.charAt(count);
		if ((c<"0" || c>"9") && (c!=".")&& (c!="-")){
				 sValue=sValue.substring(0, count) + sValue.substring(count+1, sValue.length);
		}
		
	}

	if (sValue==''){
	 oChamps.value='';
	 return;
	}
	dValue=parseFloat(sValue)// au cas ou il y aurait un "." en trop
	oChamps.value=dValue.toString()
	sStr=oChamps.value
	if (sBornes!=''){
		var i=0
		var ld
		var oTest
		oTest = new Array()
		oTest = sBornes.split(",")
		var lDec=oTest[2]
		var lMin=oTest[0]
		var lMax=oTest[1]
		//on retire les décimales en trop
		i=sStr.indexOf(".")+1
		ld=sStr.length-i
		if ((ld>lDec)&&(i!=0)) {
			alert('Attention : seulement ' + lDec + ' décimales admises')
			sStr= sStr.substring(0,sStr.length-(ld-lDec))
			oChamps.value=sStr
		}
		if (parseFloat(sStr)<parseFloat(lMin) || parseFloat(sStr)>parseFloat(lMax)) {
			alert("Valeur erronée. Elle doit être comprise entre " + lMin + " et " + lMax);
			oChamps.value="";
			oChamps.focus();
			verifier=false
		}
	}
	return verifier;
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierEmail
// ------------------
// Description : Vérifier si le champs est un Email
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierEmail(oChamps) {
	var pos, point,value;
	value=oChamps.value;
	if(value!=""){
		pos=value.indexOf("@")+1;
		if (pos>1) {
			point=value.indexOf(".", pos);
			if (point>pos && point<value.length-1) return true;
		}
		alert("L'adresse e-mail est erronée");
		oChamps.value="";
		oChamps.focus();
		return false;
	}else{
		return true;
	}
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierTel
// ------------------
// Description : vérifier si c'est bien un numéro de téléphone
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierTel(oChamps) {
	str="";
	numero=oChamps.value
	count=numero.length;
	if (count<=0) return str;
	while (--count>=0) {
		c=numero.charAt(count);
		if (c<"0" || c>"9") numero=numero.substring(0, count) + numero.substring(count+1, numero.length);
	}

	for (count=0; count<numero.length; count++) {
		if (count>0 && count%2==0) str+=" ";
		str+=numero.charAt(count);
	}
	oChamps.value=str;
	return true;
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierSiren
// ------------------
// Description : vérifier si c'est bien un numéro de siren
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 16/06/2004 - Hélène
// --------------------------------------------------------------------
function VerifierSiren(oChamps) {
	str="";
	numero=oChamps.value
	count=numero.length;
	if (count<=0) return str;
	while (--count>=0) {
		c=numero.charAt(count);
		if (c<"0" || c>"9") numero=numero.substring(0, count) + numero.substring(count+1, numero.length);
	}

	for (count=0; count<numero.length; count++) {
		if (count>0 && count%3==0) str+=" ";
		str+=numero.charAt(count);
	}
	oChamps.value=str;
	return true;
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierSiret
// ------------------
// Description : vérifier si c'est bien un numéro de siret
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 16/06/2004 - Hélène
// --------------------------------------------------------------------
function VerifierSiret(oChamps) {
	str="";
	numero=oChamps.value
	count=numero.length;
	if (count<=0) return str;
	while (--count>=0) {
		c=numero.charAt(count);
		if (c<"0" || c>"9") numero=numero.substring(0, count) + numero.substring(count+1, numero.length);
	}

	for (count=0; count<9; count++) {
		if (count>0 && count%3==0) str+=" ";
		str+=numero.charAt(count);
	}
	str+=" " +numero.substr(9,5);

	//oChamps.value=str;
	oChamps.value=str;
	return true;
}
//--------------------------------------------------------------------
// Nom de la fonction : VerifierMillier
// ------------------
// Description : mise en forme des séparateur de millier
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 19/10/2004 - Hélène
// --------------------------------------------------------------------
function VerifierMillier(oChamps) {
	str="";
	numero=oChamps.value
	numero = '' + numero
	if (numero.length > 3) {
        var mod = numero.length%3;
        var output = (mod > 0 ? (numero.substring(0,mod)) : '');
        for (i=0 ; i < Math.floor(numero.length/3) ; i++) {
            if ((mod ==0) && (i ==0))
                output+= numero.substring(mod+3*i,mod+3*i+3);
            else
                output+= ' ' + numero.substring(mod+3*i,mod+3*i+3);
        }

		oChamps.value=output;
		return true;
    }  
    
}

//--------------------------------------------------------------------
// Nom de la fonction : VerifierChaine
// ------------------
// Description : vérifie la longueur d'une chaîne
// -----------
//
// Paramètres : oChamps
// ----------	lLongueur max   Le nombre de caractère maxi de la chaîne
//				bFixe			si vrai alors la chaîne doit faire lLongueur caractère
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// -------------------------------------------------------------------
function VerifierChaine(oChamps,sListArguments){
	var str;
	var oTest = new Array()
	oTest = sListArguments.split(',')
	if (oTest.length==1){
		if (oChamps.value.length>oTest[0]) alert("Le champ doit avoir au maximum "+oTest[0]+" caractères");
		str=oChamps.value
		oChamps.value=str.substring(0,oTest[0]);
	}
	else {
		if (oChamps.value.length!=oTest[0]){
			alert("La longueur du champ doit être "+oTest[0]+" caractères");
			oChamps.value="";
			return false;}
	}
	return true;
}


//--------------------------------------------------------------------
// Nom de la fonction : VerifierHeure
// ------------------
// Description : vérifie si un champs est bien une heure
// -----------
//
// Paramètres : oChamps
// ----------
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------

function VerifierHeure(oChamps) {
var	c, cpt, count,str;
	str=oChamps.value;
	count=str.length;
	if (count<=0) oChamps.value="";
	cpt=0;
	while (cpt<count) {
		c=str.charAt(cpt);
		if (c>="0" && c<="9") break;
		cpt++;
	}
	h=(cpt<count) ? parseInt(str.substring(cpt, count), 10) : 0;

	cpt=count;
	while (--cpt>=0) {
		c=str.charAt(cpt);
		if (c<"0" || c>"9") break;
	}
	m=(cpt>0 && cpt<count-1) ? parseInt(str.substring(cpt+1, count), 10) : 0;

	if (0<=h && h<=23 && 0<=m && m<=59) {
		oChamps.value=Int2Str(h,2)+":"+Int2Str(m,2);return true;}
	else {
		alert("Le format horaire n'est pas valide");
		oChamps.value="";
		oChamps.focus();
	}
	return false;
	
	
}

function Int2Str(num, digit) {
var	str, count;

	str=num.toString();
	count=digit-str.length;
	if (count>0) {
		while (--count>=0) str="0"+str;
	}
	return str;
}

function Str2Int(str) {
var	c, cpt, count;

	count=str.length;
	if (count<=0) return 0;
	for (cpt=0; cpt<count; cpt++) {
		c=str.charAt(cpt);
		if (c>="0" && c<="9") return parseInt(str.substring(cpt, count), 10);
	}
	return 0;
}

function Str2Dbl(str) {
var	c, cpt, count;

	count=str.length;
	if (count<=0) return 0;
	for (cpt=0; cpt<count; cpt++) {
		c=str.charAt(cpt);
		if ((c>="0" && c<="9") || (c==".")) return parseFloat(str.substring(cpt, count));
	}
	return 0;
}


//====================================================================================
//  définition d'un tableau servant à la vérification des champs date 
//====================================================================================

function DefinitTableau(NbElem) {
  this.length=NbElem;
  var i;
  for(i=1;i<=NbElem;i++)
    this[i]=0;
  return(this); 
  }
//====================================================================================
// Nom : Jour
// Description : rend le jour d'une date. (sdate) en fonction du format stype (local ou us)
// Précondition : le format de la date est sensé être valide;
// 
// 
// Auteur :		Stef
// Mise à jour : Stef le 03/06/1999
//====================================================================================

function Jour(sDate,sType){
	 var result;
	 result=0;
	 tableauDate=new DefinitTableau(10);
     for(j=0;j < sDate.length;j++)                       
     tableauDate[j] = sDate.charAt(j); 
     if (sType=="local") {
		result=10*tableauDate[0];
		result+=tableauDate[1]*1;}
    else {
		result=10*tableauDate[3];
		result+=tableauDate[4]*1;
		};

	return result;
	
     }
     
 //====================================================================================
// Nom : Mois
// Description : rend le mois d'une date. (sdate) en fonction du format stype (local ou us)
// Précondition : le format de la date est sensé être valide;
// 
// 
// Auteur :		Stef
// Mise à jour : Stef le 03/06/1999
//====================================================================================

function Mois(sDate,sType){
	 var result;
	 tableauDate=new DefinitTableau(10);
     for(j=0;j < sDate.length;j++)                       
     tableauDate[j] = sDate.charAt(j);
     
     if (sType=="local") {
		result= 10*tableauDate[3];
		result+= tableauDate[4] -1 ;}
     else 
		{result= 10*tableauDate[0];
		result+=tableauDate[1]-1;};
     
     return result;
     }
     
//====================================================================================
// Nom : Annee
// Description : rend l'annee d'une date. (sdate) en fonction du format stype (local ou us)
// Précondition : le format de la date est sensé être valide;
// 
// 
// Auteur :		Stef
// Mise à jour : Stef le 03/06/1999
//====================================================================================

function Annee(sDate,sType){
	 tableauDate=new DefinitTableau(10);
     for(j=0;j < sDate.length;j++)                       
     tableauDate[j] = sDate.charAt(j); 
     return parseInt(tableauDate[6] + tableauDate[7] + tableauDate[8] + tableauDate[9]); 
     
     }
     

//--------------------------------------------------------------------
// Nom de la fonction : VerifierHorodate
// ------------------
// Description : vérifie si une date est inférieure ou égale à une autre
// -----------
//
// Paramètres : Obligatoire i,j : indices du champ dans le formulaire
// ----------
//
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------

function verifierHorodate(i,j){
	var d1,d2 
	d1 = new Date();
	d2 = new Date();
	if (document.forms[0].elements[i].value==""||document.forms[0].elements[j].value=="") return true;
	d1.setDate(Jour(document.forms[0].elements[i].value,"local"));
	d1.setMonth(Mois(document.forms[0].elements[i].value,"local"));
	d1.setYear(Annee(document.forms[0].elements[i].value,"local"));
	d2.setDate(Jour(document.forms[0].elements[j].value,"local"));
	d2.setMonth(Mois(document.forms[0].elements[j].value,"local"));
	d2.setYear(Annee(document.forms[0].elements[j].value,"local"));
	if (d1>=d2) 
		{
		return false;
		}
	return true;
}

//------------------------------------------------------------------
// Nom de la fonction : Confirmer
// ------------------
// Description : Demande confirmation par boite de dialogue
// -----------
//
// Paramètres : Obligatoires:
// ----------
//							sLien: Lien à éxécuter suite à la confirmation
//							sMessage: Message à afficher dans la boite dD
// Date de création : 29/10/1999 - Stef
// ----------------
// Date de dermière mise à jour : 29/10/1999 - Stef
// ----------------------------
// --------------------------------------------------------------------
function Confirmer(sLien, sMessage)
{
	//demande de confirmation
	var bChoixOK = window.confirm(sMessage);
	//si le choix est OK (confirmation)
	if (bChoixOK)
	{
		//redirection
		window.location = sLien;
	}	
}

function verifierHorodateObjet(oDate1,oDate2){
	var d1,d2 
	d1 = new Date();
	d2 = new Date();
	if (oDate1.value=="//"||oDate2.value=="//") return false;
	d1.setDate(Jour(oDate1.value,"local"));
	d1.setMonth(Mois(oDate1.value,"local"));
	d1.setYear(Annee(oDate1.value,"local"));
	d2.setDate(Jour(oDate2.value,"local"));
	d2.setMonth(Mois(oDate2.value,"local"));
	d2.setYear(Annee(oDate2.value,"local"));
	if (d1>d2) 
		{
		return false;
		}
	return true;
}

function FormatNom(str,index) {
	if (index==1) {
		v="";
		
		flag=true;
		count=str.length;
		for (cpt=0; cpt<count; cpt++) {
			c=str.charAt(cpt);
			if (c==" " && flag) continue;
			if (c==" ") c="-";
			if (c=="é" || c=="è" || c=="ê" || c=="ë") c="e";
			if (c=="à" || c=="â" || c=="ä") c="a";
			if (c=="î" || c=="ï" || c=="ï") c="i";
			if (c=="ö" || c=="ô") c="o";
			c=(flag) ? c.toUpperCase() : c.toLowerCase();
			flag=c=="-";
			v+=c;
		}
		return v;
	} else if (index==2) {
		v="";
		count=str.length;
		for (cpt=0; cpt<count; cpt++) {
			c=str.charAt(cpt);
			if (c=="é" || c=="è" || c=="ê" || c=="ë") c="e";
			if (c=="à" || c=="â" || c=="ä") c="a";
			if (c=="î" || c=="ï" || c=="ï") c="i";
			if (c=="ö" || c=="ô") c="o";
			v+=c;}
			v=v.toUpperCase();
			return v
	}
	return str;
}


//---------------------------------------------------------------------------
// <Nom>          completerDate
// <Description>  Complète le champ de saisie [oDate], lorsque celui-ci 
//                contient une date
// <Parametres>   (I) oDate = Champ date du formulaire
// <Resultats>    Vrai si la date contenue dans le champ est valide, faux sinon
//---------------------------------------------------------------------------
function completerDate(oDate)
{
	var sDate  = String(oDate.value);
	var sJour  = formatNombre(String(new Date().getDate()+1),2);
	var sMois  = formatNombre(String(new Date().getMonth()+1),2);
	var sAnnee = formatNombre(String(new Date().getFullYear()),4);
	var cSeparateur = (sDate.indexOf('-')==-1) ? '/' : '-';		// '/' pr défaut
	var iTmp;
	var tDate;

	// retrouver le type de séparateur
	if (sDate.indexOf('/')!=-1)
		cSeparateur = '/';
	else if	(sDate.indexOf('-')!=-1)
		cSeparateur = '-';
	else if	(sDate.indexOf(' ')!=-1)
		cSeparateur = ' ';
	else if	(verifieNombre(sDate))
		cSeparateur = '/';
	else
		return afficherErreur(oDate);
	
	// On sépare les éléments de la date
	tDate = sDate.split(cSeparateur);

	// On traite les différent types
	switch(tDate.length) {		
	
	case 0:		//pas de date
		return;
		
	case 1:		//du type JJ ou JJMM ou JJMMAAAA ou J ou ...				
		if (!verifieNombre(tDate[0]))
			return afficherErreur(oDate);
		switch(tDate[0].length) {
			case 0:	// date vide
				return;
			case 1: // J
			case 2: // JJ
				oDate.value = formatNombre(tDate[0],2) + cSeparateur + sMois + cSeparateur + sAnnee;	
				break;
			case 3: // JJM
			case 4:	// JJMM
				oDate.value = formatNombre(tDate[0].substring(0,2),2) + cSeparateur + formatNombre(tDate[0].substring(2,tDate[0].length),2) + cSeparateur + sAnnee;	
				break;
			case 5: // JJMMA
			case 6:	// JJMMAA
				if(parseFloat(tDate[0].substring(4,tDate[0].length))>25)
					oDate.value = formatNombre(tDate[0].substring(0,2),2) + cSeparateur + formatNombre(tDate[0].substring(2,4),2) + cSeparateur + '19' + formatNombre(tDate[0].substring(4,tDate[0].length),2);
				else
					oDate.value = formatNombre(tDate[0].substring(0,2),2) + cSeparateur + formatNombre(tDate[0].substring(2,4),2) + cSeparateur + '20' + formatNombre(tDate[0].substring(4,tDate[0].length),2);
				break;
			case 7: // 
			case 8:
				oDate.value = formatNombre(tDate[0].substring(0,2),2) + cSeparateur + formatNombre(tDate[0].substring(2,4),2) + cSeparateur + formatNombre(tDate[0].substring(4,tDate[0].length),4);
				break;
			default:
				return afficherErreur(oDate);
		}
		break;

	case 2:		//du type JJ/MM ou J/M ou JJ/MMAAAA ou ...
		if (!verifieNombre(tDate[0]))
			return afficherErreur(oDate);
		tDate[0] = formatNombre(tDate[0],2);
		if (!verifieNombre(tDate[1]))
			return afficherErreur(oDate);
		switch(tDate[1].length) {
			case 0:
				oDate.value = tDate[0] + cSeparateur + sMois + cSeparateur + sAnnee;	
				break;
			case 1:
			case 2:
				oDate.value = tDate[0] + cSeparateur + formatNombre(tDate[1].substring(0,2),2) + cSeparateur + sAnnee;
				break;
			case 3:
			case 4:
				if(parseFloat(tDate[1].substring(2,tDate[1].length))>25)
					oDate.value = tDate[0] + cSeparateur + formatNombre(tDate[1].substring(0,2),2) + cSeparateur + '19' + formatNombre(tDate[1].substring(2,tDate[1].length),2);
				else
					oDate.value = tDate[0] + cSeparateur + formatNombre(tDate[1].substring(0,2),2) + cSeparateur + '20' + formatNombre(tDate[1].substring(2,tDate[1].length),2);
				break;
			case 5:
			case 6:
				oDate.value = tDate[0] + cSeparateur + formatNombre(tDate[1].substring(0,2),2) + cSeparateur + formatNombre(tDate[1].substring(2,tDate[1].length),4);
				break;
			default:
				return afficherErreur(oDate);
		}
		break;
		
	case 3:		//du type JJ/MM/AA ou J/M/AAAA ou JJ/MM/AAAA ou ...
		if (!verifieNombre(tDate[0]))
			return afficherErreur(oDate);
		tDate[0] = formatNombre(tDate[0],2);
		if (!verifieNombre(tDate[1]))
			return afficherErreur(oDate);
		tDate[1] = formatNombre(tDate[1],2);
		if (!verifieNombre(tDate[2]))
			return afficherErreur(oDate);
		switch(tDate[2].length) {
			case 0:
				oDate.value = tDate[0] + cSeparateur + tDate[1] + cSeparateur + sAnnee;	
				break;
			case 1:
			case 2:
				if(parseFloat(tDate[2])>25)
					oDate.value = tDate[0] + cSeparateur + tDate[1] + cSeparateur + '19' + formatNombre(tDate[2],2);
				else
					oDate.value = tDate[0] + cSeparateur + tDate[1] + cSeparateur + '20' + formatNombre(tDate[2],2);
				break;
			case 3:
			case 4:
				oDate.value = tDate[0] + cSeparateur + tDate[1] + cSeparateur + formatNombre(tDate[2],4);	
				break;
			default:
				return afficherErreur(oDate);
		}
		break;

	default:		
		return afficherErreur(oDate);		
	}  // switch
	
	if (!verifieDate(oDate.value,cSeparateur))
		return afficherErreur(oDate);
		
	return true;
}

//---------------------------------------------------------------------------
// <Nom>          formatNombre
// <Description>  Fomatte le nombre [sNombre] pour qu'il prenne [iTaille]
//                caractères. Le formattage consiste à compléter par des 0
// <Parametres>   (I) sNombre = Nombre à formatter
//                (I) iTaille = Taille du nombre une fois formatté
// <Resultats>    Le nombre formatté
//---------------------------------------------------------------------------
function formatNombre(sNombre,iTaille)
{
	var i = iTaille - sNombre.length;
	var sTmp='';

	while(i--)
		sTmp += '0';

	return sTmp+sNombre;
}

//---------------------------------------------------------------------------
// <Nom>          verifieNombre
// <Description>  Vérifie si la chaîne [sNombre] contient un nombre
// <Parametres>   (I) sNombre = Chaîne à tester
// <Resultats>    Vrai si [sNombre] contient un nombre, faux sinon
//---------------------------------------------------------------------------
function verifieNombre(sNombre)
{
	var i;
	
	for(i=0;i<sNombre.length;i++)
		if (sNombre.charAt(i)<"0" || sNombre.charAt(i)>"9")
			return false;

	return true;
}

//---------------------------------------------------------------------------
// <Nom>          afficherErreur
// <Description>  Affiche un message d'erreur signalant que la date saisie
//                n'est pas valide
// <Parametres>   (I) oDate = Champ date du formulaire
// <Resultats>    Faux, toujours.
//---------------------------------------------------------------------------
function afficherErreur(oDate)
{
	oDate.select();
	//oDate.focus();
	//document.oDate.focus();
	alert('La date n\'est pas valide !');
	oDate.value="";
	oDate.select();
	//oDate.focus();

	
	return false;
}

//---------------------------------------------------------------------------
// <Nom>          bissextile
// <Description>  Vérifie si l'année [iAnnee] est bissextile
// <Parametres>   (I) iAnnee = Annee que l'on veut tester
// <Resultats>    Vrai si bissextile, faux sinon
//---------------------------------------------------------------------------
function bissextile(iAnnee)
{
	return (iAnnee % 4 == 0) && ( (iAnnee % 400 == 0) && (iAnnee % 100 == 0) || (iAnnee % 100 != 0) );
}

//---------------------------------------------------------------------------
// <Nom>          verifieDate
// <Description>  Vérifie que la date [sDate] est valide
// <Parametres>   (I) sDate = Date dont on veut tester la validité
//                (I) cSeparateur = Caractère séparant les éléments de la date ['/','-',' ']
// <Resultats>    Vrai si la date est valide, faux sinon
//---------------------------------------------------------------------------
function verifieDate(sDate,cSeparateur)
{
	var tDate = sDate.split(cSeparateur);
	var tJoursMois = [31,29,31,30,31,30,31,31,30,31,30,31];
	var iJour = parseFloat(tDate[0]);
	var iMois = parseFloat(tDate[1])-1;
	var iAnnee = parseFloat(tDate[2]);
	
	if (iMois<0 || iMois>11)
		return false;
		
	if (iJour<0 || iJour>tJoursMois[iMois])
		return false;
		
	if (iMois==1 && !bissextile(iAnnee) && iJour>28)
		return false;
		
	return true;
}

//---------------------------------------------------------------------------
// <Nom>          PopUp
// <Description>  ouvre une pop up à partir d'un lien
// <Parametres>   (I) url = le chemin de l'image
//				  (I) name = le nom que portera la fenêtre
//                (I) features = les attribut que l'on veut spécifier,
//					             comme par exemple la taille ou la position
// <Resultats>    
//---------------------------------------------------------------------------
function PopUp(url, name, features)
{
	window.open(url, name, features);
	return;
}

function OuvrirCalendrier(monform,monobjet){
	var Nouveaucontenu = "";
	sFeatures="top=150px,left=300px,width=190px,height=170px;toolbar:yes;location:no;directories:no;status:no;menubar:no;scrollbars:no;resizable:no;"
	window.open("/_Include/intranet/biblio/calendrier.asp?datDebut=" + eval("document." + monform + "." + monobjet + ".value")+"&formulaire=" + monform + "&objet=" + monobjet,'_blank',sFeatures);
}









function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v4.01
  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 && d.getElementById) x=d.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}
//-->


<!--
function MM_reloadPage(init) {  //reloads the window if Nav4 resized
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
    document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
  else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}
MM_reloadPage(true);
//-->
function DecomposeDate(LeParam1){ 

// Sépare les jours, les mois et les années dans une date de type "22/05/1981"
// Renvoye le tout dans un tableau de taille 3

LeRetour = new Array(3);
LeJour="";
LeMois="";
LeAnnee="";

// Extraction du jour
i=0;
while((LeParam1.charAt(i)!="/")&&(i<10)){
LeJour+=LeParam1.charAt(i);
i++;
}
if(LeJour.charAt(0)=="0"){
LeJour=LeJour.charAt(1);
}
LeParam1=LeParam1.substring(i+1,LeParam1.length);

// Extraction du mois
i=0;
while((LeParam1.charAt(i)!="/")&&(i<10)){
LeMois+=LeParam1.charAt(i);
i++;
}
if(LeMois.charAt(0)=="0"){
LeMois=LeMois.charAt(1);
}
LeParam1=LeParam1.substring(i+1,LeParam1.length);


// Extraction de l'année
LeAnnee=LeParam1;
LeRetour[0]=LeJour;
LeRetour[1]=LeMois;
LeRetour[2]=LeAnnee;
return LeRetour;
}


function DateAnglaise(LeParam1,LeParam2){

LaDate = new Array(3);
LaDate = DecomposeDate(LeParam1);

LeRetour = LaDate[2]+LeParam2+LaDate[1]+LeParam2+LaDate[0];
return LeRetour;
}

function ComparerDates(LeParam1,LeParam2){
	
	// Compare 2 dates au format jj/mm/aaaa
	// Renvoye 0 si égalité, 1 si la première est supérieure, sinon 2
	
	var LeParam1 = DateAnglaise(LeParam1,"/");// Ne pas oublier d'utiliser cette fonction
	// pour convertir en date anglaise, sinon le 05/07/2003 sera compris "7 mai 2003" par JavaScript
	
	var LeParam2 = DateAnglaise(LeParam2,"/");
	LeParam1 = Date.parse(LeParam1);
	LeParam2 = Date.parse(LeParam2);
	
	if (LeParam1 == LeParam2) { 
	return 0;
	}
	
	if (LeParam1 > LeParam2){
		return 1;
	}else{
	return 2;
	}
	}
	
function renverseStrDate(sIn) { //1ere procedure renverse date
  var sOut = "";
  // : 01346789
  //-->67893401
  sOut = sIn.charAt(6) + sIn.charAt(7) + sIn.charAt(8)+ sIn.charAt(9) + "/" + sIn.charAt(3)+ sIn.charAt(4) + "/" + sIn.charAt(0)+ sIn.charAt(1)
  
  return(sOut);
}