//--------------------------------------------------------------------
// Nom du module  : Form.js
// ----------------
// Description : un ensemble de fonctions Javascript pour le contrôle 
// -----------	 de la saisie dans un formulaire et la contrôle des 
//				 champs obligatoires
//
// Date de dermière mise à jour : Nico - mai 2001
// ----------------------------
// --------------------------------------------------------------------







//--------------------------------------------------------------------
// Nom de la fonction : LesArguments
// ------------------
// Description : prend une chaîne 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 LesArguments("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 de 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 : l'indice du formulaire concerné
// ----------	 sListChampsObl : liste des champs obligatoires
//				 sDestination : l'URL de destination du formulaire (optionnel)
//				 bSubmit :  Flag spécifiant si l'on soumet ou non le formulaire
//							lorsque celui-ci est valide (true par défaut)
//				 Exemple d'appel : ValiderForm(0,'"Nom","Prenom"','Validation.asp',true)
//
// 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 : 12/01/2000 - Olivier
// ----------------------------
// --------------------------------------------------------------------

function ValiderForm2(myFormID,sListChampsObl,sDestination,bSubmit){
	var bStop
	var bValeur
	var tabArgs //Tableau des arguments
	var oChamps
	var i=0
	var sType
	var lCpt=0
	var myForm
	
	bStop=false;
	
	myForm=document.getElementById(myFormID);
	eval("tabArgs= new LesArguments(" + sListChampsObl + ")")
	while (i<tabArgs.length){
		eval('oChamps=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" || sType=="password") && 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;
		}
	if (bSubmit == null || bSubmit)
		document.forms[myForm].submit();
	return true;
}

function ValiderForm(myForm,sListChampsObl,sDestination,bSubmit){
	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.forms[' + 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" || sType=="password") && 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;
		}
	if (bSubmit == null || bSubmit)
		document.forms[myForm].submit();
	return true;
}


function ValiderFormByID(formID,sListChampsObl,sDestination,bSubmit){
	var bStop
	var bValeur
	var tabArgs //Tableau des arguments
	var oChamps
	var i=0
	var sType
	var lCpt=0
	var oForm
	
	bStop=false
	
	oForm = document.getElementById(formID);
	
	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=="password") && 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<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.");document.forms[myForm].elements[lCpt].focus();return;
			}
		}
		i++
	}
	if (sDestination != null)
		{
		document.forms[myForm].action = sDestination;
		}
	if (bSubmit == null || bSubmit)
		oForm.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)  
//				 sListLesArguments	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 : 14/02/2001 - Matt
// ----------------------------
// --------------------------------------------------------------------
function VerifierType(oChamps,sType,sListLesArguments){
	if (sType=="Date") return completerDate(oChamps); //VerifierDate(oChamps,sListLesArguments);
	if (sType=="Entier") return VerifierEntier(oChamps,sListLesArguments);
	if (sType=="Reel") return VerifierReel(oChamps,sListLesArguments);
	if (sType=="Tel") return VerifierTel(oChamps);
	if (sType=="Email") return VerifierEmail(oChamps);
	if (sType=="Chaine") return VerifierChaine(oChamps,sListLesArguments);
	if (sType=="Heure") return VerifierHeure(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 : 15/02/2001 - Matt
// ----------------------------
// --------------------------------------------------------------------
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) {
			alert("Valeur erronée. Elle ne doit pas être inférieure à " + lMin + ".");
			oChamps.value="";
			oChamps.focus();
			verifier=false
		}
		else if (numero>lMax) {
			alert("Valeur erronée. Elle ne doit pas être supérieure à " + 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 : 15/02/2001 - Matt
// ----------------------------
// --------------------------------------------------------------------
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!=".") && (c!="-")){
			sValue=sValue.substring(0, count) + sValue.substring(count+1, sValue.length);
			}
		else if (c == ","){
			sValue=sValue.substring(0, count) + "." + sValue.substring(count+1, sValue.length);
			}
		
	}
	
	dValue=parseFloat(sValue); // au cas ou il y aurait un "." en trop
	oChamps.value=dValue.toString();
	if (sValue=='') {
		oChamps.value='';	
		return false;
		}
	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)) {
			alert("Valeur erronée. Elle ne doit pas être inférieure à " + lMin + ".");
			oChamps.value="";
			oChamps.focus();
			verifier=false
		}
		else if (parseFloat(sStr)>parseFloat(lMax)) {
			alert("Valeur erronée. Elle ne doit pas être supérieure à " + 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 : 10/07/2001 - Stef
// ----------------------------
// --------------------------------------------------------------------
function VerifierEmail(oChamps) {
	var pos, point,value,i,temp;
	value=oChamps.value;
	temp="";
	for (i=0;i<value.length;i++){
		if(value.charAt(i)!=' '){
			temp=temp+value.charAt(i);
		}
	}
	value=temp;
	pos=value.indexOf("@")+1;
	if (pos>1) {
		point=value.indexOf(".", pos);
		oChamps.value=value.toLowerCase();
		if (point>pos && point<value.length-1) return true;
	}
	alert("L'adresse e-mail est erronée");
	oChamps.value="";
	oChamps.focus();
	return false;
}

//--------------------------------------------------------------------
// 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) {
	var str,numero,count,c;//ajout Adj

	str="";
	numero=oChamps.value
	count=numero.length;
	//test : la chaine est elle nulle? si oui on retourne la chaine
	if (count<=0) return str;
	
	//récupération du numéro "exact"
	//si la valeur n'est pas un chiffre, elle est supprimée
	while (--count>=0) {
		c=numero.charAt(count);
		if (c<"0" || c>"9") numero=numero.substring(0, count) + numero.substring(count+1, numero.length);
	}//end while
	
	//formatage : les numéros sont groupés par deux.
	for (count=0; count<numero.length; count++) {
		if (count>0 && count%2==0) str+=" ";
		str+=numero.charAt(count);
	}//end for
	
	oChamps.value=str;
	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,sListLesArguments){
	var str;
	var oTest = new Array()
	oTest = sListLesArguments.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;
}

//====================================================================================
//  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(numform,i,j){
	var d1,d2 
	d1 = new Date();
	d2 = new Date();
	if (document.forms[numform].elements[i].value==""||document.forms[numform].elements[j].value=="") return true;
	d1.setDate(Jour(document.forms[numform].elements[i].value,"local"));
	d1.setMonth(Mois(document.forms[numform].elements[i].value,"local"));
	d1.setYear(Annee(document.forms[numform].elements[i].value,"local"));
	d2.setDate(Jour(document.forms[numform].elements[j].value,"local"));
	d2.setMonth(Mois(document.forms[numform].elements[j].value,"local"));
	d2.setYear(Annee(document.forms[numform].elements[j].value,"local"));
	if (d1>d2) 
		{
		return false;
		}
	return true;
}

//---------------------------------------------------------------------------
// <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>          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();
	alert('La date n\'est pas valide !');

	return false;
}

//---------------------------------------------------------------------------
// <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>          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>          InscriptionEmail
// <Description>  Inscrit une personne à la mailing list
//
// <Parametres>   (I) obj : nom du formulaire (i.e. "document.frmLogin")
//
// <Resultats>	  Ouverture d'une pop up ou message d'erreur si l'email est erroné
//---------------------------------------------------------------------------
function InscriptionEmail(obj)
{
	if (VerifierType(obj.email,'Email','')) 
		{window.open('http://www.comptanoo.com/MailingList/securitePopUp.asp?Act=Insc&E=P&ML=178&email=' + obj.email.value,'InscrEmailPopUp','width=300,height=200,toolbars=no')}
		else return;
}

//---------------------------------------------------------------------------
// <Nom>          fnTrapKD
// <Description>  Intercepte l'action d'envoi de formulaire par la touche entrée
//
// <Parametres>   (I) obj : nom du formulaire (i.e. "document.frmLogin")
//
// <Resultats>	  Lance InscriptionEmail (voir ci-dessus) si la touche entrée 
//				  a été pressée
//---------------------------------------------------------------------------
function fnTrapKD(obj){
   if(event.keyCode == 13){
    event.returnValue=false;
    InscriptionEmail(obj);
   }
}


//---------------------------------------------------------------------------
// <Nom>          InsereTexte
// <Description>  Insere le texte "texte" dans l'objet de formulaire obj
//				  et place le curseur à la fin de la zone de saisie
//
// <Parametres>   (I) obj : nom de l'objet de formulaire
//---------------------------------------------------------------------------
function InsereTexte(obj,texte)
{
	obj.value = texte;
	
	if (obj.createTextRange) {
		var range = obj.createTextRange();
		range.collapse(false);
        range.select();
	}
}

//---------------------------------------------------------------------------
// <Nom>          InsereTexte
// <Description>  Efface le texte de l'objet de formulaire
//
// <Parametres>   (I) obj : nom de l'objet de formulaire
//---------------------------------------------------------------------------
function EffaceTexte(obj)
{
	obj.value='';
}



//---------------------------------------------------------------------------
// <Nom>          MajusculeChamp
// <Description>  Met le texte d'un champ en majuscule
//
// <Parametres>   (I) obj : nom du champ
//
// <Date de création> 10/07/2002 - Adrien
// 
// <Date de dermière mise à jour> 10/07/2002 - Adrien
//---------------------------------------------------------------------------

function MajusculeChamp(obj)
{
var x;
x=obj.value;
obj.value=x.toUpperCase();
}



//---------------------------------------------------------------------------
// <Nom>          MajMinChamp
// <Description>  Met les initiales du texte d'un champ en majuscule et force
//				  tous les autres caractéres en minuscule
//				  Le texte est dans un premier temps stocké dans sTexte, il
//				  est ensuite formaté est placé dans sTexteFormat
//				  cf. exemple dans inscription/ficheadherent.asp
// <Parametres>   (I) obj : nom du champ
//
// <Date de création> 10/07/2002 - Adrien
// 
// <Date de dermière mise à jour> 10/07/2002 - Adrien
//---------------------------------------------------------------------------

function MajMinChamp(obj)
{
var sTexte;			//chaine contenant le texte
var sTexteFormat;	//chaine contenant le texte formaté
var x;				//variable temporaire
var i;				//sert dans la boucle
var flag;			//booléen pour les majuscules "internes"

//Initialisations
flag=0;
sTexte=obj.value;
//Le premier caractère est mis en majuscule et placé dans sTexteFormat
x=sTexte.charAt(0).toUpperCase();
sTexteFormat=x;

//parcours de la boucle, formatage et concaténation à sTexteFormat
for(i = 1; i < sTexte.length; i++) {       
	if (flag) {
		x=sTexte.charAt(i).toUpperCase();
		sTexteFormat=sTexteFormat+x;
		flag=0;
	}
	else {
		x=sTexte.charAt(i).toLowerCase();
		sTexteFormat=sTexteFormat+x;
	}
	if ((sTexte.charAt(i)==' ') || (sTexte.charAt(i)=='-')){
			flag=1;
	//le flag est à 1 lorsque le prochain caractère sera en majuscule 
	}
}

obj.value=sTexteFormat;
}

//--------------------------------------------------------------------
// Nom de la fonction : trim
// ------------------
// Description : enlève les blancs à droite et à gauche
// -----------       
function trim(s) {
	var r=/\b(.*)\b/.exec(s);
    return (r==null)?"":r[1];
}


/*
* Faire fonctionner la touche entrer avec internet explorer pour le login
*/
window.onload = function(e) {
    $('#frmLogin input').keyup(function(e) {
        if (e.which == 13) {
            $("#frmLogin").submit();
        }
    });
    $('#frmLoginPage input').keyup(function(e) {
        if (e.which == 13) {
            $("#frmLoginPage").submit();
        }
    });
}