/**
 * Vérifie qu'un caractère soit un chiffre
 * @param chiffre le caractère à vérifier
 * @return true si le carcatère est un chiffre
 */
function isChiffre(chiffre)
{
	return (chiffre>='0' && chiffre<='9');
}


/**
 * Vérifie qu'une chaine de caractères soit un nombre
 * @param nombre la chaine de caractères à vérifier
 * @return true si la chaine est un nombre
 */
function isInteger(nombre)
{
	var n = nombre.length;
	for(var i=0; i<n; i++)
	{
   	if (! isChiffre(nombre.charAt(i)))
		{
			return false;
		}
	}
	return (n > 0);
}

/**
 * Vérifie qu'une chaine de caractères soit un nombre négatif
 * @param nombre la chaine de caractères à vérifier
 * @return true si la chaine est un nombre
 */
function isIntegerNatural(nombre)
{
	var n = nombre.length;
	if (n > 0)
	{
		var prem = nombre.charAt(0);
		if (prem=='-')
			return (isInteger(nombre.substring(1,n)));
		else return (isInteger(nombre));
	}
	else 
		return false;
}


/**
 * Vérifie qu'une chaine de caractères soit un nombre plus grand qu'une valeur
 * @param s la chaine de caractères à vérifier
 * @return true si la chaine est un nombre
 */
function isIntegerMin(s, min)
{
  return isInteger(s) && s>=min;
}


/**
 * Vérifie qu'une chaine de caractères soit un nombre compris entre deux valeurs
 * @param s la chaine de caractères à vérifier
 * @return true si la chaine est un nombre
 */
function isIntegerMinMax(s, min, max)
{
  return isInteger(s) && s>=min && s<=max;
}


/**
 * Vérifie qu'une chaine de cractères soit un nombre réel positif
 * @param s la chaine de caractères à vérifier
 * @return true si la chaine est un nombre réel positif
 */
function isRealPositif(s)
{
	var containSep = false;
	var n = s.length;

	for(var i=0; i<n; i++)
	{
		var c = s.charAt(i);
		if (!isChiffre(c))
		{
			if((c=='.' || c==',') && !containSep)
			{ // Séparateur (c'est le 1er)
			  containSep = true;
			}
			else
			{ // Ni chiffre ni séparateur, ou 2è séparateur
				return false;
			}
		}
	}
	return (n>0);	
}

/**
 * Vérifie qu'une chaine de cractères soit un nombre réel
 * @param s la chaine de caractères à vérifier
 * @return true si la chaine est un nombre réel
 */
function isReal(nombre)
{
	var n = nombre.length;
	if (n > 0)
	{
		var prem = nombre.charAt(0);
		if (prem=='-')
			return (isRealPositif(nombre.substring(1,n)));
		else return (isRealPositif(nombre));
	}
	else 
		return false;
}

/**
 * Vérifie la taille d'une chaine de caractères
 * @param s la chaine de caractères dont on vérifie la longueur
 *	@param n la taille attendue de la chaine
 * @return true si la chaine de caractères a la longueur attendue, false sinon
 */
function hasLength(s, n)
{
	return (s.length==n);
}


/**
 * Vérifie qu'une chaine de caractères a au moins un certain nombre de caractères
 * @param s la chaine de caractères dont on vérifie la longueur
 * @param n la taille attendue de la chaine
 */
hasMinLength = function (s, n)
{
	return (s.length>=n);
}


/**
 * Vérifie qu'une chaine de caractères a au plus un certain nombre de caractères
 * @param s la chaine de caractères dont on vérifie la longueur
 *	@param n la taille attendue de la chaine
 */
function hasMaxLength(s, n)
{
	return (s.length<=n);
}


/**
 * Vérifie que la taille d'une chaine de caractères est comprise entre deux
 * nombres
 * @param s la chaine de caractères dont on vérifie la longueur
 * @param inf la taille minimale attendue pour la chaine
 * @param sup la taille maximale attendue pour la chaine
 */
function hasMinMaxLength(s, inf, sup)
{
	var l = s.length;
	return (l>=inf && l<=sup);
}


/**
 * Vérifie qu'un nombre est supérieur à un autre nombre
 * @param val le nombre à tester
 *	@param seuil le nombre auquel doit être supérieur le nombre à tester
 * @return true si le nombre testé est supérieur ou égal à l'autre nombre, false
 *		s'il est inférieur
 */
function hasMinValue(val, seuil)
{
	return (val>=seuil);
}


/**
 * Vérifie qu'un nombre est inférieur à un autre nombre
 * @param val le nombre à tester
 * @param seuil le nombre auquel doit être inférieur le nombre à tester
 * @return true si le nombre testé est inférieur ou égal à l'autre nombre, false
 *		s'il est supérieur
 */
function hasMaxValue(val, seuil)
{
	return (val<=seuil);
}


/**
 * Vérifie qu'un nombre est compris entre deux autres nombres
 * @param val le nombre à tester
 *	@param inf la valeur minimale pour le nombre à tester
 *	@param sup la valeur maximale pour le nombre à tester
 * @return true si le nombre testé est compris entre les deux autres nombres,
 * 	false sinon
 */
function hasMinMaxValue(val, inf, sup)
{
	return (val>=inf && val<=sup);
}


/**
 * Vérifie qu'une chaine a un format de date (jj/mm/aaaa) valide.
 */
function isDate(date)
{
	if (hasLength(date, 10))
	{
		var d = date.substring(0, 2);
		var m = date.substring(3, 5);
		var y = date.substring(6, 10);
		if(isInteger(d) && isInteger(m) && isInteger(y) &&
				date.charAt(2)=='/' && date.charAt(5) == '/')
		{
			var b = hasMinMaxValue(y, 1900, 2500);
			b = b && hasMinMaxValue(m, 1, 12);
			switch(m)
			{
			case 1:case 3:case 5: case 7: case 8: case 10: case 12:
				b = b && hasMinMaxValue(d, 1, 31);
				break;
			case 4:case 6:case 9: case 11:
				b = b && hasMinMaxValue(d, 1, 30);
				break;
			case 2:
				b = b && hasMinMaxValue(d, 1, 29);
				break;
			}
			return b;
		}
	}
	return false;
}


/**
 * Vérifie qu'une chaine a un format de date (jj/mm/aaaa - HH:mm:ss) valide.
 */
function isDateHeure(date)
{
	if (hasLength(date, 21))
	{
		var d = date.substring(0, 2);
		var m = date.substring(3, 5);
		var y = date.substring(6, 10);
		var h = date.substring(13, 15);
		var mm = date.substring(16, 18);
		var s = date.substring(19, 21);
		if(isInteger(d) && isInteger(m) && isInteger(y) && isInteger(h) && isInteger(mm) && isInteger(s) &&
			date.charAt(2)=='/' && date.charAt(5) == '/' && date.charAt(15) == ':' && date.charAt(18) == ':')
		{
			var b = hasMinMaxValue(y, 1900, 2500);
			b = b && hasMinMaxValue(m, 1, 12);
			b = b && hasMinMaxValue(h, 0, 24);
			b = b && hasMinMaxValue(mm, 0, 59);
			b = b && hasMinMaxValue(s, 0, 59);
			switch(m)
			{
			case 1:case 3:case 5: case 7: case 8: case 10: case 12:
				b = b && hasMinMaxValue(d, 1, 31);
				break;
			case 4:case 6:case 9: case 11:
				b = b && hasMinMaxValue(d, 1, 30);
				break;
			case 2:
				b = b && hasMinMaxValue(d, 1, 29);
				break;
			}
			return b;
		}
	}
	return false;
}


/**
 * Vérifie si une date est postérieure à une date seuil.
 * isDateAfter("12/03/2000","05/03/2000" retourne true
 * isDateAfter("12/03/2000","27/04/2000" retourne false
 * Le format des dates est supposé cohérent
 * @param date la date à tester
 * @param seuil la date après laquelle doit être la date à tester
 */
function isDateAfter(date, seuil)
{
	var d = date.substring(0, 2);
	var m = date.substring(3, 5);
	var y = date.substring(6, 10);
	var d1 = seuil.substring(0, 2);
	var m1 = seuil.substring(3, 5);
	var y1 = seuil.substring(6, 10);

	if(y>y1)
	{
		return true;
	}
	else if(y==y1)
	{
		if(m>m1)
		{
			return true;
		}
		else if(m==m1)
		{
			return d>=d1;
		}
	}
	return false;
}


/**
 * Vérifie si une date est antérieure à une date seuil. Le format des dates est
 * supposé cohérent.
 * @param date la date à tester
 * @param seuil la date avant laquelle doit être la date à tester
 */
function isDateBefore(date, seuil)
{
	var d = date.substring(0, 2);
	var m = date.substring(3, 5);
	var y = date.substring(6, 10);
	var d1 = seuil.substring(0, 2);
	var m1 = seuil.substring(3, 5);
	var y1 = seuil.substring(6, 10);

	if(y<y1)
	{
		return true;
	}
	else if(y==y1)
	{
		if(m<m1)
		{
			return true;
		}
		else if(m==m1)
		{
			return d<=d1;
		}
	}
	return false;
}


/**
 * Vérifie si une date est comprise entre deux dates. Le format des dates est
 * supposé cohérent
 * @param date la date à tester
 * @param inf la date après laquelle doit être la date à tester
 * @param sup la date avant laquelle doit être la date à tester
 */
function isDateBetween(date, inf, sup)
{
	return isDateAfter(date, inf) && isDateBefore(date, sup);
}




////////////////////////////////////////////////////////////////////////////////
//
// Fonctions pour valider le contenu de champs de formulaire HTML
//


/**
 * Valide qu'un champ contient une date
 */
function ddvDate(champ_date, msg)
{
	if(! isDate(champ_date.value))
	{
		alert(msg);
		champ_date.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient une date postérieure à une autre
 */
function validateDateAfter(champ_date, autredate)
{
	if(! isDateAfter(champ_date.value, autredate))
	{
		alert("Date invalide.\nVeuillez saisir une date postérieure au " + autredate + ".\nLe format de sasie est jj/mm/aaaa.");
		champ_date.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient une date antérieure à une autre
 */
function validateDateBefore(champ_date, autredate)
{
	if(! isDateBefore(champ_date.value, autredate))
	{
		alert("Date invalide.\nVeuillez saisir une date antérieure au " + autredate + ".\nLe format de sasie est jj/mm/aaaa.");
		champ_date.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient une date postérieure à une autre
 */
function validateDateBetween(champ_date, autredate, autredate2)
{
	if(! isDateBetween(champ_date.value, autredate, autredate2))
	{
		alert("Date invalide.\nVeuillez saisir une date comprise entre le " + autredate + " et le " + autredate2 + ".\nLe format de sasie est jj/mm/aaaa.");
		champ_date.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient au moins un certain nombre de caractères
 */
ddvMinLength = function (champ, n, msg)
{
	if(! hasMinLength(champ.value, n))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient au plus un certain nombre de caractères
 */
function validateMaxLength(champ, n)
{
	if(! hasMaxLength(champ.value, n))
	{
		alert("Veuillez ne pas saisir plus de " + n + " caractères.");
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient entre tant et tant de caractères
 */
function ddvMinMaxLengthMsg(champ, min, max, msg)
{
	if(! hasMinMaxLength(champ.value, min, max))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient un nombre entier positif
 */
function ddvInteger(champ, msg)
{
	if(! isInteger(champ.value))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient un nombre entier positif plus grand qu'une valeur
 */
function ddvIntegerMinMsg(champ, min, msg)
{
	if(! isIntegerMin(champ.value, min))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient un nombre entier positif
 */
function ddvIntegerMinMax(champ, min, max, msg)
{
	if(! isIntegerMinMax(champ.value, min, max))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide qu'un champ contient un nombre
 */
function ddvFloat(champ, msg)
{
	if (! isReal(champ.value))
	{
		alert(msg);
		champ.focus();
		return false;
	}
	return true;
}


/**
 * Valide un mot de passe. Le mot de passe a été saisi deux fois par
 * l'utilisateur dans des zones de texte masuqées. Il faut donc vérifier qu'il
 * a bien tapé 2 fois le même mot de passe.
 * @param champ1 la 1ère zone de texte où l'utilisateur a saisi le mot de passe
 * @param champ2 la 2ème zone de texte où l'utilisateur a saisi le mot de passe
 * @param minlength nombre minimum de cractères pour le mot de passe
 * @param msg message demandant de saisir le mot de passe
 */
function ddvPassword(champ1, champ2, minlength, msg)
{
	// Taille min pour le 1er champ
	if(!ddvMinLength(champ1, minlength, msg)) return false;
	// Le 2ème champ doit avoir le même contenu que le 1er
	if(champ1.value != champ2.value)
  {
		alert(msg);
    champ1.value = "";
    champ2.value= "";
    champ1.focus();
    return false;
  }
  else
  {
  	return true;
  }
}


/**
 * Valide qu'une liste a bien une valeur de sélectionnée au dela d'un certain
 * index. Ceci permet par exemple d'obliger à l'utilisateur à sélectionner un
 * item qui ne soit pas le 1er d'une combo (dans le cas ou on veut laisser
 * vide le 1er item d'une combo).
 */
ddvItemSelection = function (champ, index, msg)
{
	if(champ.selectedIndex < index)
  {
    alert(msg);
		champ.focus();
    return false;
  }
  else
  {
		return true;
  }
}

/**
 * Valide qu'un des bouton radio soit sélectionné parmis un groupe de boutons
 * radio.
 */
ddvRadio = function (champ, msg)
{
	var comp;
	if (champ.length == null)
	{	// Si qu'un seul bouton radio, ie ne nous envoie pas un tableau mais direct l'elt
		if (champ.checked) return true;
		comp = champ;
	}
	else
	{
		for(i=0; i<champ.length; i++)
		{
		  if(champ[i].checked) return true;
		}
		comp = champ[0];
	}
	alert(msg);
	comp.focus();
	return false;
}
function validateRadioChecked(champ)
{
	validateRadioCheckedMsg(champ, "Veuillez sélectionner une valeur.");	
}

function ddvChecked(theForm, chkName, msg)
{
	lName = chkName.length;
	for(i = 0, n = theForm.elements.length; i < n; i++)
	{
		var elt = theForm.elements[i];
		if (elt.type == "checkbox" && elt.name.substr(0,lName) == chkName && elt.checked) return true;
	}
	// Pas trouvé
	alert(msg);
	return false;
}


/**
 * Valide qu'un champ ne soit pas vide
 */
ddvRequired = function (champ, msg)
{
	if(champ.value == null || champ.value == "")
   {
		alert(msg);
		champ.focus();
		return false;
	}
	else
	{
		return true;
	}
}


/**
 * Valide la saisie multiple dans un champ (l'utilisateur peut saisir plusieurs
 * valeurs séparées par un délimiteur) avec vérification des doublons.
 * @param arrayRef tableau de String contenant les valeurs possibles
 * @param stringToSplit la chaîne à vérifier saisie par l'utilisateur
 * @param separator le séparateur des valeurs
 */
function validateWithSeparator(arrayRef, stringToSplit, separator)
{
	if (stringToSplit=="") return true;
	var trouve = false;
	arrayOfStrings = stringToSplit.split(separator);
	for (var i=0; i < arrayOfStrings.length; i++)
	{
		trouve=false;
		for (var j=0; j < arrayRef.length; j++)
		{
  			if (arrayRef[j]==arrayOfStrings[i]) trouve=true;
		}
		if (!trouve) return false;
	}
	var doublon = false;
	arrayDoublon = new Array(arrayOfStrings.length);
	for (var k=0; k < arrayOfStrings.length; k++)
	{
		for (var m=0; m < arrayDoublon.length; m++)
		{
  			if (arrayDoublon[m]==arrayOfStrings[k]) doublon=true;
		}
		arrayDoublon[k]=arrayOfStrings[k];
	}
	return !doublon;
}



/**
 * Valide qu'une adresse email soit bien saisie
 */
ddvEmail = function (champ, msg, required)
{
	if (typeof required == "undefined")
	{
		required = true;
  }
	
	var s = champ.value;
	var b = true;
	if (s == '')
	{
		b = ! required;
	}
	else
	{
		var l = s.length;
		var i1 = s.indexOf("@");
		var i2 = s.indexOf(".", i1+1);
		var i3 = s.indexOf(" ");
		if (l<5 || i3!=-1 || i1<1 || (i2-i1<2) ||	(l-i2<2))
		{
			b = false;
		}
		else
		{
			b = true;
		}
	}
	
	if (!b)
	{
		alert(msg);
		champ.focus();
	}
	return b;
}