///////////////////////////////////////////
//fonction lancée au chargement des pages//
///////////////////////////////////////////
function chargement(){
}
	
///////////////////////////////////////////////////////
//fonction permettant de rediriger la page vers url  //
///////////////////////////////////////////////////////
function redirige(url){
	document.location.href=url;
}

///////////////////////////////////////
//gestion des cookies//////////////////
///////////////////////////////////////

function EcrireCookie(nom, valeur){
	var argv=EcrireCookie.arguments;
	var argc=EcrireCookie.arguments.length;
	var expires=(argc > 2) ? argv[2] : null;
	var path=(argc > 3) ? argv[3] : null;
	var domain=(argc > 4) ? argv[4] : null;
	var secure=(argc > 5) ? argv[5] : false;
	document.cookie=nom+"="+escape(valeur)+
	((expires==null) ? "" : ("; expires="+expires.toGMTString()))+
	((path==null) ? "" : ("; path="+path))+
	((domain==null) ? "" : ("; domain="+domain))+
	((secure==true) ? "; secure" : "");
}

function getCookieVal(offset){
	var endstr=document.cookie.indexOf (";", offset);
	if (endstr==-1) endstr=document.cookie.length;
	return unescape(document.cookie.substring(offset, endstr));
}

function LireCookie(nom){
	var arg=nom+"=";
	var alen=arg.length;
	var clen=document.cookie.length;
	var i=0;
	while (i<clen){
		var j=i+alen;
		if (document.cookie.substring(i, j)==arg) return getCookieVal(j);
		i=document.cookie.indexOf(" ",i)+1;
		if (i==0) break;
	}
	return null;
}

///////////////////////////////////////
///////////////////////////////////////



function change_classe(formulaire,champ,etat) {
  eval("document." + formulaire + "." + champ).className = etat;
}

//////////////////////////////////////////////////////////////////
//test de validité des données entrées dans le formulaire/////////
//////////////////////////////////////////////////////////////////

String.prototype.trim = function() {

 // skip leading and trailing whitespace
 // and return everything in between
  var x=this;
  x=x.replace("/^\s*(.*)/", "$1");
  x=x.replace("/(.*?)\s*$/", "$1");
  return x;
}


function emailValidation(entered, alertbox){
	with (entered){
		apos=value.indexOf("@"); 
		dotpos=value.lastIndexOf(".");
		lastpos=value.length-1;
		if (apos < 1 || dotpos-apos < 2 || lastpos-dotpos > 3 || lastpos-dotpos < 2 || lastpos>49) 
		{
			if (alertbox) {alert(alertbox);}
			return false;
		}else {
			return true;
		}
	} 
}

// Vérification d'un date
function isDate(d) {
  // Cette fonction permet de vérifier la validité d'une date au format jj/mm/aa ou jj/mm/aaaa
  // Par Romuald
  
  if (d == "") // si la variable est vide on retourne faux
    return false;
  
  e = new RegExp("^[0-9]{1,2}\/[0-9]{1,2}\/([0-9]{2}|[0-9]{4})$");
  
  if (!e.test(d)) // On teste l'expression régulière pour valider la forme de la date
    return false; // Si pas bon, retourne faux

  // On sépare la date en 3 variables pour vérification, parseInt() converti du texte en entier
  j = parseInt(d.split("/")[0], 10); // jour
  m = parseInt(d.split("/")[1], 10); // mois
  a = parseInt(d.split("/")[2], 10); // année

  // Si l'année n'est composée que de 2 chiffres on complète automatiquement
  if (a < 1000) {
    if (a < 89)  a+=2000; // Si a < 89 alors on ajoute 2000 sinon on ajoute 1900
    else a+=1900;
  }

  // Définition du dernier jour de février
  // Année bissextile si annnée divisible par 4 et que ce n'est pas un siècle, ou bien si divisible par 400
  if (a%4 == 0 && a%100 !=0 || a%400 == 0) fev = 29;
  else fev = 28;

  // Nombre de jours pour chaque mois
  nbJours = new Array(31,fev,31,30,31,30,31,31,30,31,30,31);

  // Enfin, retourne vrai si le jour est bien entre 1 et le bon nombre de jours, idem pour les mois, sinon retourn faux
  return ( m >= 1 && m <=12 && j >= 1 && j <= nbJours[m-1] );
}


// Vérifié qu'il s'agit bien d'une date
// entered : objet contenant la date
// alertbox : le mesage en cas d'erreur
function dateValidation(entered, alertbox){

	with (entered){
		if (isDate(entered.value) == false){
			if (alertbox!="") {alert(alertbox+"\n"+"Le format est (JJ/MM/AAAA)");} 
			return false;
		}
		else {return true;}
	}	
}

// Vérifie que l'Objet donné est bien renseigné TRUE si c'est rempli
// entered : l'objet a vérifier
// alertbox : le message en cas d'erreur
function emptyValidation(entered, alertbox){
	with (entered){
		if (value==null || value==""){
			if (alertbox!="") {alert(alertbox);} 
			return false;
		}
		else {return true;}
	}
}


function listeValidation(entered, alertbox){
	with (entered){

		checkValue = "";
		isNumber = true;

  		MyArrayOfS=value.split(",");
		
		
		// On enleve tous les caractères non numériques
		for (i = 0; i<MyArrayOfS.length ; i = i+1){
			c = MyArrayOfS[i];
			if (isNaN(c) == true || c.trim() == ""){
				if (alertbox) {alert(alertbox);}
				return false;
			}
			
		}
		
		return true;
	}
}

// Vérifie que la valeur se trouve bien dans l'interval entre min et max
function digitValidation(entered, min, max, alertbox){
	with (entered){

		checkValue = "";
		// On enleve tous les caractères non numériques
		for (i = 0; i<value.length ; i = i+1){
			c = value.charAt(i);
			if ((isNaN(c) == false) && (c != " ")){
				checkValue = checkValue+value.charAt(i);
			}
			
		}
		
		if ((checkValue.length < min) || (checkValue.length > max) || isNaN(checkValue)){
			if (min != max){
				if (alertbox!="") {alert(alertbox+"\n"+"Le champ doit comporter entre "+min+" et "+max+" chiffres");} 
				return false;
			}
			else{
				if (alertbox!="") {alert(alertbox+"\n"+"Le champ doit comporter exactement "+min+" chiffres");} 
				return false;
			}
			
		}
		else {return true;}
	}
} 

function digitValidationStrict(entered, min, max, alertbox){
	with (entered){

		checkValue = "";
		// On enleve tous les caractères non numériques
		for (i = 0; i<value.length ; i = i+1){
			c = value.charAt(i);
			
			if ((isNaN(c) == false) && (c != " ")){
				checkValue = checkValue+value.charAt(i);
			}
			else {
				if (c != " "){
				 
					if (alertbox!="") {alert(alertbox+"\n"+"Le champ doit comporter entre "+min+" et "+max+" chiffres");} 
					return false;			
				}
			}
			
		}
		
		if ((checkValue.length < min) || (checkValue.length > max) || isNaN(checkValue)){
			if (min != max){
				if (alertbox!="") {alert(alertbox+"\n"+"Le champ doit comporter entre "+min+" et "+max+" chiffres");} 
				return false;
			}
			else{
				if (alertbox!="") {alert(alertbox+"\n"+"Le champ doit comporter exactement "+min+" chiffres");} 
				return false;
			}
			
		}
		else {return true;}
	}
} 

function digitValidationStrict2(entered, min, max){
	with (entered){

		checkValue = "";
		// On enleve tous les caractères non numériques
		for (i = 0; i<value.length ; i = i+1){
			c = value.charAt(i);
			
			if ((isNaN(c) == false) && (c != " ")){
				checkValue = checkValue+value.charAt(i);
			}
			else {
				if (c != " "){
				 
					alert("Le code postal doit comporter "+min+" ou "+max+" chiffres (departement ou ville)."); 
					return false;			
				}
			}
			
		}
		
		if (((checkValue.length != min) && (checkValue.length != max)) || isNaN(checkValue)){
			alert("Le code postal doit comporter "+min+" ou "+max+" chiffres (departement ou ville).");
			return false;
		}
		else {return true;}
	}
} 

// Fonction permettant de vérifier une valeur numérique
// ----------------------------------------------------
// - Si min != max : vérifie que le nombre est bien dans la fourchette donnée
// - Si la valeur contient un ',' il est remplacé par '.'
// - vérifcation qu'il ne s'agit pas d'un NaN, avec datatype non renseigné
// ----------------------------------------------------
// entered : l'OBJET contenant la valeur
// min : la valeur minimal
// max : la valeur maximale
// alertbox : est le texte retourné en cas d'erreur
// datatype : une vérification au niveau du type
// 
function valueValidation(entered, min, max, alertbox, datatype){
	
	
	
	with (entered){
	
		valeur = value.replace(/\,/g,".");
				
		if (isNaN(valeur) == true) {
					
				if (alertbox != "") {
					
						alert(alertbox);
						return false;
						
				} 
					
		}
		checkvalue=parseFloat(valeur);
		if (datatype){
			
			smalldatatype=datatype.toLowerCase();
			
			if (smalldatatype.charAt(0)=="i") {
				checkvalue=parseInt(valeur);
			}
			
			if (min != max) {
				if ((parseFloat(min)==min && checkvalue < min) || (parseFloat(max)==max && checkvalue > max) || value!=checkvalue){
					if (alertbox!="") {
						alert(alertbox+"\n"+"Le champ doit être compris entre "+min+" et "+max);
					} 
					return false;
				}
				return true;
			
			}
			else return true;
			
			
		}
		else {return true;}
	}
	
} 

//////////////////////////////////////////////////////////////////////////
// fonction permettant d'interdire les caractères autre que 0-9 + - et .
///////////////////////////////////////////////////////////////////////////
function valideFloat(obj,e){
	//var reg_point =  /(\d*)\.(\d*)/;
	//var reg_plus_moins =  /((\+)|(\-))(\d*)(\.(\d*)?)?/;
	var reg_float= /(\d*)\.(\d\d)/;
    var reg_point =  /(\d*)\.(\d?\d?)/;
    var reg_plus_moins =  /((\+)|(\-))(\d*)(\.(\d?\d?)?)?/;

    var is_safari=(navigator.vendor=="Apple Computer, Inc." && navigator.vendor!="Firefox");
    
	var code;
	if(document.all)code=e.keyCode;
	else code=e.which;
	//alert(code);
	//transformation de la , en .
	if(code==44 && !reg_point.test(obj.value)){
		
  		if(typeof document.selection != 'undefined') {
    		/* Insertion du code de formatage */
    		var range = document.selection.createRange();
    		var insText = range.text;
    		range.text = String.fromCharCode(46);
   		}	
		/* pour navigateurs plus récents basés sur Gecko*/
		else if(typeof obj.selectionStart != 'undefined')
		{
		    /* Insertion du code de formatage */
		    var start = obj.selectionStart;
		    var end = obj.selectionEnd;
		    var insText = obj.value.substring(start, end);
		    obj.value = obj.value.substr(0, start) + String.fromCharCode(46) + obj.value.substr(end);
		    /* Ajustement de la position du curseur */
		    var pos;
		    if (insText.length == 0) {
		      pos = start + 1;
		    } else {
		      pos = start + 1;
		    }
		    obj.selectionStart = pos;
		    obj.selectionEnd = pos;
  		}else if(is_safari){
  			
  			/*var gs=document.getSelection();
  			alert(gs);
  			var range = gs.createRange();
    		var insText = range.text;
    		range.text = String.fromCharCode(46);*/
  			obj.value=obj.value+String.fromCharCode(46);
  		}
  		return false;
	}
	
	if(code==63234 || code==63235){
		return true;
	}
	
	//soit [0-9] ou autre touche F1 ... ou backspace ou . ou tabulation ou + ou -	
	if( (code>=48 && code<=57) || code==0 || code==8 || code==9 || (code==46 && !reg_point.test(obj.value)) || ((code==43 ||code==45) && !reg_plus_moins.test(obj.value)) ){
		if(code==43 || code==45){
			obj.value=String.fromCharCode(code)+obj.value;
			return false;
		}
		if((code>=48 && code<=57) && reg_float.test(obj.value)){
			return false	
		}
		return true;
	}else{
		if(code==43 || code==45){
			obj.value=String.fromCharCode(code)+obj.value.substr(1);	
		}
		return false;
	}
}

function virguleToPoint(obj){
	
	/*obj.value.replace(/[,]/g,".");	
	alert("test"+obj.value.match(/,/g));*/
}

////////////////////////////////////////////////////////////////
// fonction permettant d'interdire les caractères autre que 0-9 
////////////////////////////////////////////////////////////////
function valideInteger(obj,e){
	var code;
	if(document.all)code=e.keyCode;
	else code=e.which;
	
	//soit [0-9] ou autre touche F1 ... ou backspace
	if((code>=48 && code<=57) || code==0 || code==8 || code==9){
		return true;
	}else{
		return false;
	}
}


////////////////////////////////////////////////////////////////
// fonction permettant d'interdire les caractères autre que 0-9 
////////////////////////////////////////////////////////////////
function valideInt(value){
	var reg = new RegExp("^[0-9]*$","g");
	return !reg.test(value);
}

////////////////////////////////////////////////////////////////
// fonction permettant de verifier la validité d'une url
////////////////////////////////////////////////////////////////
function valideUrl(value){
	var reg = new RegExp("^http://[_A-Z0-9-]+\.[_A-Z0-9-]+[.A-Z0-9-]*(/~|/?)[/_.A-Z0-9#?&=+-]*$");	
	return true;//!reg.test(value);
}

////////////////////////////////////////////////////////////////////////////
// fonction permettant d'enlever les espaces avant une chaine de caractère
////////////////////////////////////////////////////////////////////////////
function string_ltrim() {
	var str = this.valueOf();
	while ((str.charCodeAt(0) == 160) || (str.charAt(0) == "\t") || (str.charAt(0) == " ") ) {
  		str = str.substring(1,str.length);
	}
	return str;
}
//on l'associe à l'objet String
String.prototype.ltrim = string_ltrim;

//confirme l'action
function confirmation(text){
	return confirm(text);
}

//enlève les accents
function noaccent(chaine) {
	temp = chaine.replace(/[àâä]/gi,"a")
    temp = temp.replace(/[éèêë]/gi,"e")
    temp = temp.replace(/[îï]/gi,"i")
    temp = temp.replace(/[ôö]/gi,"o")
    temp = temp.replace(/[ùûü]/gi,"u")
    return temp
}

//teste si la touche cliquer n'est pas la touche entrée
function is_not_enter(e){
	var code;
	if(document.all)code=e.keyCode;
	else code=e.which;
	
	if(code==13)return false;
	else return true; 
}

// fonction explode 
function explode(chaine,separateur){
	var res=new Array();
	var i=0;
	var temp="";
	
	for(i=0;i<=chaine.length;i++){
		if(chaine.charAt(i)==separateur){
			if(temp!=""){
				if(res.length!=null){
					res[res.length]=temp;
				}else{
					res[0]=temp;	
				}
				temp="";
			}
		}
		else{
			
			temp+=chaine.charAt(i);
		}		
	}
	res[res.length]=temp;
	if(temp!=""){
		if(res.length!=null){
			res[res.length]=temp;
		}else{
			res[0]=temp;	
		}
	}	
	return res;
}

// compare 2 dates, elle renvoie :
//	- 0 quand égale;
//	- -1 quand la première date est inférieure à la seconde;
//	- 1 quand la première date est supérieure à la seconde;
//	- false pour un format de date invalide.
function compare_date(date_debut,date_fin){
	var date1 = new Array();
	var date2 = new Array();

	// on test si la date de début est valide
	if(!isDate(date_debut)){
		return false;
	}
	else{
		// on test si la date de début est valide
		if(!isDate(date_fin)){
			return false;
		}
		else{
			date1 = explode(date_debut,"/");
			date2 = explode(date_fin,"/");
			// on test si les deux dates sont équivalentes
			if(date1[2] == date2[2] && date1[1] == date2[1] && date1[0] == date2[0]){
				return 0;
			}
			// l'une est forcément inférieure à l'autre
			else{
				// on test les années si date1 > date2 alors date1 supérieure
				if(date1[2] < date2[2]){
					return -1;	
				}
				else{
					if(date1[2] > date2[2]){
						return 1;
					}
					else{
						// on doit tester les mois
						if(date1[1] < date2[1]){
							return -1;	
						}
						else{
							if(date1[1] > date2[1]){
								return 1;	
							}
							else{
								// on doit tester les jours
								if(date1[0] < date2[0]){
									return -1;	
								}
								else{
									return 1;
								}
							}
						}
					}
				}		
			}
		}
	}
}


////////////////////////////////////////////////////////////////
// fonction permettant de verifier une couleur en hexadecimal
////////////////////////////////////////////////////////////////
function isColor(c){
	var reg= /\#([0-9,a-f,A-F])([0-9,a-f,A-F])([0-9,a-f,A-F])([0-9,a-f,A-F])([0-9,a-f,A-F])([0-9,a-f,A-F])/;
    return reg.test(c);
}	

////////////////////////////////////////////////////////////////
// fonction permettant de verifier un horaire du type 12:00
////////////////////////////////////////////////////////////////
function isHoraire(c){
	var reg= /(20|21|22|23|[0-1]\d):[0-5]\d/;
    return reg.test(c);
}