/************************************************
**     LIBRAIRIE DE FONCTIONS STANDARD SIGMA   **
**       Fonction de gestion des types         **
********************************************************************************************
**  version 1.50  - 13/04/2007 - RGUEGAN - + ajout de verifierDuree (Transport)
**  version 1.45  - 07/03/2007 - RGUEGAN - * bug sur convertirStringToDate (lorsque l'année contenait un 0 devant)
**                                         + ajoute le mois s'il est manquant sur la saisie d'une date
**  version 1.40  - 30/03/2005 - RGUEGAN - * bug sur Stringtofloat (lorsque séparateur == ',')
**  version 1.39  - 21/03/2005 - RGUEGAN - * std_verifierDate utilise globale_FormatDate au lieu de CONSTANTE_FORMAT_DATE_FR
**  version 1.38  - 21/04/2004 - RGUEGAN - * bug convertirNombreEntier "01","" renvoyait NaN
**  version 1.37  - 14/01/2004 - RGUEGAN - * bug verifNombreEntier "1-1" renvoyait true
**  version 1.36  - 03/11/2003 - RGUEGAN - * bug sur convertirStringToInteger, pour les nombres commençant par 0
**  version 1.35  - 12/11/2002 - RGUEGAN - * remplacement de . par globale_SeparateurDecimal
**  version 1.34  - 05/11/2002 - RGUEGAN - * remplacement de / par globale_SeparateurDate
**
*******************************************************************************************/

///////////////////////////////////////////
// Variables globales
///////////////////////////////////////////
///////////////////////////////////////////

var globale_SeparateurMilliers = " ";
var globale_SeparateurDecimal  = "."
var globale_SeparateurDate     = "/";
var globale_MessageErreur      = "";
var globale_AnneePivot         = 49;
var globale_dernierCodeErreur = ""; // Codes internes, qui sont amenés à changer //var globale_MessageErreur = "";
var globale_FormatDate        = "dd/mm/yyyy"
var globale_codePays          = "fr";
var CONSTANTE_FORMAT_DATE_FR  = "dd/mm/yyyy";
var CONSTANTE_JAVASCRIPT_SEPARATEUR_MILLIERS = "";
var CONSTANTE_JAVASCRIPT_SEPARATEUR_DECIMAL  = ".";
var CONSTANTE_JAVASCRIPT_SEPARATEUR_NEUTRE   = "#";  // n'apparait jamais dans un chiffre, n'est pas un séparateur possible
var CONSTANTE_ALPHABET_ALPHANUMERIQUE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var CONSTANTE_ALPHABET_NUMERIQUE      = "0123456789";

///////////////////////////////////////////
// Fonctions de Vérification
///////////////////////////////////////////
///////////////////////////////////////////
//
// std_XX : fonction utilisateurs
// prv_XX : fonction interne (private)

function std_verifierIntegerBornes(Chaine, valeurMinimum, valeurMaximum, SeparateurMilliers)
{
  retour = true;
  nombreATester = std_convertirStringToInteger(Chaine, SeparateurMilliers);
  if ( ! isNaN (nombreATester) )
  {
     if ((nombreATester >= valeurMinimum) && (nombreATester <= valeurMaximum))
     {
       retour = true;
     }
     else
     {
       retour = false;
     }
  }
  else
  {
     retour = false;
  }
  return retour;
}

function std_verifierInteger(Element, SeparateurMilliers)
{
  valeurInteger = std_convertirStringToInteger(Element, SeparateurMilliers);
  if (isNaN (valeurInteger) )
  {
    return false;
  }
  else
  {
    return true;
  }
}

function std_verifierIntegerMessage(element, chaine)
{
  valElem = element.value;
  valeurInteger = std_convertirStringToInteger(valElem);
  if (isNaN (valeurInteger) ) {
  	if (chaine == undefined) { //on traite le cas où on n'a pas de libellé de champ
  		chaine = '';
  	} else if (chaine != '') { //On traite le cas où on a un libellé vide
  		chaine += ' ';
  	}
    alert("Le champ "+chaine+" doit être un entier.");
    //On enlève les caractères incorrects
    var chaineFinale = '';
    for (var i = 0; i < valElem.length; i++) {
    	var caracCour = valElem.charAt(i)
		if (caracCour >= "0" && caracCour <= "9") {
	    	chaineFinale += valElem.charAt(i);
	    }
	}
    element.value = chaineFinale;
    return false;
  } else {
  	return true;
  }
}

function std_verifierNombre(Chaine, SeparateurMilliers, SeparateurDecimal)
{
  retour = true;
  parametreValide = true;
  if (arguments.length == 1)
  {
     SeparateurMilliers = globale_SeparateurMilliers
     SeparateurDecimal  = globale_SeparateurDecimal
     parametreValide = true;
  }
  else if (arguments.length == 2)
  {
     SeparateurDecimal = globale_SeparateurDecimal
     parametreValide = true;
  }
  else if (arguments.length == 3)
  {
     parametreValide = true;
  }
  else
  {
     globale_dernierCodeErreur = "SF01" // S = systeme, F = Appel de fonction, 01 = mauvais nombre de parametres dans l'appel de la fonction
     parametreValide = false;
  }

  if (parametreValide == true)
  {
    retour = prv_verifierNombre(Chaine, SeparateurMilliers, SeparateurDecimal )
  }
  else
  {
    retour = false;
  }
  return retour;
}

// Permet de tester si la valeur est un nombre (entier ou decimal)
function prv_verifierNombre(Chaine, SeparateurMilliers, SeparateurDecimal)
{
  resultat = false;
  Chaine = std_trimDebut(Chaine);
  Chaine = std_trimFin(Chaine);
  var re = new RegExp("(^-?[0-9]{1,3}(["+SeparateurMilliers+"][0-9]{3})*(["+SeparateurDecimal+"][0-9]*)?$)|(^-?[0-9][0-9]*(["+SeparateurDecimal+"][0-9]*)?$)|(^-?(["+SeparateurDecimal+"][0-9]*)?$)","ig");
  if (re.test(Chaine))
  {
     resultat = true;
  }
  else
  {
     globale_dernierCodeErreur = "TN01" // T = Vérification de type, N = numérique, 01 = La valeur fournie n'est pas un nombre correct
     resultat = false;
  }
  return resultat;
}

function std_verifierNombreEntier(Chaine, SeparateurMilliers)
{
  if (arguments.length == 1)
  {
     SeparateurMilliers = globale_SeparateurMilliers
  }
  else
  {
     // S'il y a 0 paramètre il y a une erreur javascript
     // Sinon, c'est qu'il y en a trop
  }
  return prv_verifierNombreEntierGlob(Chaine, SeparateurMilliers, false)
}
function prv_verifierNombreEntier(Chaine, SeparateurMilliers) {
    return prv_verifierNombreEntierGlob (Chaine, SeparateurMilliers, false);
}

function std_verifierNombreEntierSansMessage(Chaine, SeparateurMilliers) {
  if (arguments.length == 1) {
     SeparateurMilliers = globale_SeparateurMilliers;
  }
  return prv_verifierNombreEntierGlob (Chaine, SeparateurMilliers, true);
}

function prv_verifierNombreEntierGlob(Chaine, SeparateurMilliers, sansMessage) {
  resultat = false;
  Chaine = std_trimDebut(Chaine);
  Chaine = std_trimFin(Chaine);
  if (Chaine[0] == "-") {
  	Chaine = Chaine.substring(0, Chaine.length);
  }
  if (std_verifierStringDansAlphabet(Chaine, CONSTANTE_ALPHABET_NUMERIQUE+SeparateurMilliers)) {
     resultat = true;
  } else if (sansMessage == undefined || !sansMessage) {
     globale_MessageErreur = "La valeur fournie n'est pas un entier.";
     alert(globale_MessageErreur);
     resultat = false;
  }
  return resultat;
}

//** verifierNombreDecimal **
// Permet de tester si la valeur est numérique
// et si le nombre de chiffre avant et après la virgule correspond
// au format desire (renvoie true si c'est bon)
function std_verifierNombreDecimal(chaineNombre, longueurPartieEntiere, longueurPartieDecimale)
{
  if ( std_verifierNombre(chaineNombre) == true )
  {
    // Suppression du separateur de millier
    chaineNombreSimple = std_remplacerTexte(chaineNombre, globale_SeparateurMilliers, "");
    // Suppression du signe -
    chaineNombreSimple = std_remplacerTexte(chaineNombreSimple, "^-", "");

    len = chaineNombreSimple.length;
    pos = chaineNombreSimple.indexOf(globale_SeparateurDecimal,0);

    // Si la position de la virgule est superieure au nb
    // de chiffres attendus avant la virgule alors ERREUR
    if (pos >= 0)
    {
      if (pos > longueurPartieEntiere)
      {
         globale_MessageErreur = "La partie entière est trop grande, elle doit contenir " + longueurPartieEntiere + " chiffres maximum";
         return false;
      }
    }
    else
    {
      // il n'ya pas de .
      if (len > longueurPartieEntiere)
      {
       // globale_MessageErreur = "La partie entière est trop grande, il doit y avoir " + longueurPartieEntiere + " chiffres maximum";
        return false;
      }
    }
    if ((pos >= 0) && ((len - pos - 1) > longueurPartieDecimale))
    {
      globale_MessageErreur = "La partie décimale est trop grande, elle doit contenir " + longueurPartieDecimale + " chiffres décimaux maximum";
      return false;
    }
    return true;
  }
  globale_MessageErreur = "La valeur fournie n'est pas un nombre";
  return false;
}

/*
function verifierInt(Chaine)
{
}

function verifierFloat(Chaine)
{
}
*/


function std_verifierDuree(Chaine)
{
// Explication de l'expression reguliere:
// ^ => debut de la chaine
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// : => separateur heures / minutes
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// : => separateur minutes / secondes
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// (:[0-9]{1,2})? => la serie separateur minutes / secondes + chiffres est present au plus une fois
// $ => fin de la chaine
  var re = new RegExp("^([0-9]{1,2}):([0-9]{1,2})(:([0-9]{1,2}))?$","ig");
  if (re.test(Chaine))
  {
    heure = Chaine.replace(re,"$1");
    minute = Chaine.replace(re,"$2");
    seconde = Chaine.replace(re,"$4");
    /*if (heure > 23)
    {
      return false;
    }*/
    if (minute > 59)
    {
       return false;
    }
    if ((seconde != "") && (seconde > 59))
    {
       return false;
    }
    return true;
  }
  return false;
}

///////////////////////////////////////////
// Date
///////////////////////////////////////////

function std_comparerDatesFr(stringDate1, stringDate2)
{
  alert("Ne plus utiliser std_comparerDatesFr ! Empeche les contrôles d'être compatibles multi-lingue ");
  dateDebut = std_convertirStringToDate(stringDate1, CONSTANTE_FORMAT_DATE_FR)
  dateFin = std_convertirStringToDate(stringDate2, CONSTANTE_FORMAT_DATE_FR)
  return dateDebut.valueOf() - dateFin.valueOf();
}

function std_comparerDates(stringDate1, stringDate2)
{
  dateDebut = std_convertirStringToDate(stringDate1, globale_FormatDate)
  dateFin = std_convertirStringToDate(stringDate2, globale_FormatDate)
  return dateDebut.valueOf() - dateFin.valueOf();
}

function std_verifierDate(Chaine, formatDate)
{
  parametreValide = true;

  if (arguments.length == 0)
  {
     parametreValide = false;
  }
  if (arguments.length == 1)
  {
     formatDate = globale_FormatDate;
  }

  if (parametreValide == true)
  {
    retour = prv_verifierDate(Chaine, formatDate)
  }
  else
  {
    retour = false;
  }
  return retour;

}

//RG-COMMUN-CTRL-DATE-VALIDE
//Retourne l'id du 1er élément date en erreur ou null si aucun problème
function verifier_dates_page() {
	var mesinputs = document.getElementsByTagName("input"); 
	if (std_getReference('champsRecherche') != undefined) {
		mesinputs = std_getReference('champsRecherche').getElementsByTagName("input"); 
	}
	for (var i=0; i<mesinputs.length; i++) {
		if (mesinputs[i].className.indexOf('date') != -1) {
			std_formatageDate(mesinputs[i]);
			//Plage de Dates
			if (mesinputs[i].value != '' && (mesinputs[i].id.indexOf('Deb') != -1 || mesinputs[i].id.indexOf('Fin') != -1)) {			
				//DateIncorrecte d'une plage de dates
				if (!std_verifierDate(mesinputs[i].value)) {
					alert('Date incorrecte.');
					std_setFocusId(mesinputs[i].id);
					return mesinputs[i].id;
				} else { //Date correcte... autres vérifs
					//Les deux éléments doivent être renseignés si on a une plage de date
					if (mesinputs[i].id.indexOf('Deb') != -1) {
						if (std_getReference(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Fin').value == '') {
							alert("Veuillez saisir complètement l'intervalle de date S.V.P.");
							std_setFocusId(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Fin');
							return mesinputs[i].id.substring(0,mesinputs[i].id.length - 3);
						}
					} else if (mesinputs[i].id.indexOf('Fin') != -1) {
						if (std_getReference(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Deb').value == '') {
							alert("Veuillez saisir complètement l'intervalle de date S.V.P.");
							std_setFocusId(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Deb');
							return mesinputs[i].id.substring(0,mesinputs[i].id.length - 3);
						}
					}
					//La date de fin doit être supérieure au début
					if (mesinputs[i].id.indexOf('Deb') != -1) {
						if (std_verifierDate(std_getReference(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Fin').value)) {
							if (std_comparerDates(mesinputs[i].value, std_getReference(mesinputs[i].id.substring(0,mesinputs[i].id.length - 3) + 'Fin').value) > 0) {
								alert("L'intervalle de date n'est pas correcte : la date de fin doit être supérieure ou égale à la date de début.");
								std_setFocusId(mesinputs[i].id);
								return mesinputs[i].id;
							}
						}
					}
				}
			//Date
			} else if (mesinputs[i].value != ''){
				//DateIncorrecte
				if (!std_verifierDate(mesinputs[i].value)) {
					alert('Date incorrecte.');
					std_setFocusId(mesinputs[i].id);
					return mesinputs[i].id;
				}
			}
		}
	}
	return null;
}

function prv_verifierDate(chaine, formatDate)
{
  if (std_convertirStringToDate(chaine, formatDate) != null)
  {
     return true;
  }
  else
  {  // globale_MessageErreur est renseigné par std_convertirStringToDate
     return false;
  }
}

function std_verifierHeure(Chaine)
{
// Explication de l'expression reguliere:
// ^ => debut de la chaine
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// : => separateur heures / minutes
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// : => separateur minutes / secondes
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// (:[0-9]{1,2})? => la serie separateur minutes / secondes + chiffres est present au plus une fois
// $ => fin de la chaine
  var re = new RegExp("^([0-9]{1,2}):([0-9]{1,2})(:([0-9]{1,2}))?$","ig");
  if (re.test(Chaine))
  {
    heure = Chaine.replace(re,"$1");
    minute = Chaine.replace(re,"$2");
    seconde = Chaine.replace(re,"$4");
    if (heure > 23)
    {
      return false;
    }
    if (minute > 59)
    {
       return false;
    }
    if ((seconde != "") && (seconde > 59))
    {
       return false;
    }
    return true;
  }
  return false;
}

function std_verifierStringDansAlphabet(chaine, alphabet)
{
        var indiceCaractere = 0;
        var caractere = '';
        var nombreCaracteresChaine = chaine.length;

        for (indiceCaractere = 0; indiceCaractere < nombreCaracteresChaine; indiceCaractere++)
        {
                caractere = chaine.charAt(indiceCaractere);
                if (alphabet.indexOf(caractere) == -1)
                {
                   return false;
                }
        }
        return true;
}

function std_verifierEmail(chaineEmail)
{
        if (chaineEmail == "")
        {
          return true;
        }
        var alphabet = CONSTANTE_ALPHABET_ALPHANUMERIQUE+".-_";

      // chercher le caractère @
        var pos1 = chaineEmail.indexOf('@');
        if (pos1 < 0)
        {
           return false; // pas de @
        }
        var pos2 = chaineEmail.lastIndexOf('@');
        if (pos1 != pos2)
        {
          return false; // plusieurs @
        }

      // à gauche, c'est la partie compte de l'email
        var compteEmail = chaineEmail.substring(0, pos1-1);
        if (compteEmail == "")
        {
           return false; // il faut un compte
        }
        if (!std_verifierStringDansAlphabet(compteEmail, alphabet))
        {
           return false; // caractères invalides ?
        }

      // à droite, c'est la partie domaine
        var domaineEmail = chaineEmail.substring(pos2+1, chaineEmail.length-1);
        if (domaineEmail == "")
        {
           return false; // il faut un domaine
        }
        if (!std_verifierStringDansAlphabet(domaineEmail, alphabet)) return false; // caractères invalides ?

        return true;
}

//SGA FM 244492 Vérification d'email au format de l'Etat X(19)@X(17).X(3)
function std_verifierEmailFormatEtat(chaineEmail)
{
        if (chaineEmail == "")
        {
          return true;
        }
        var alphabet = CONSTANTE_ALPHABET_ALPHANUMERIQUE+".-_";

      // chercher le caractère @
        var pos1 = chaineEmail.indexOf('@');
        if (pos1 < 0)
        {
           return false; // pas de @
        }
        if (pos1 > 19)
        {
           return false; // Au format de l'Etat, le compte de l'email est limité à 19 caractères
        }
        var pos2 = chaineEmail.lastIndexOf('@');
        if (pos1 != pos2)
        {
          return false; // plusieurs @
        }

      // à gauche, c'est la partie compte de l'email
        var compteEmail = chaineEmail.substring(0, pos1);
        if (compteEmail == "")
        {
           return false; // il faut un compte
        }
        if (!std_verifierStringDansAlphabet(compteEmail, alphabet))
        {
           return false; // caractères invalides ?
        }

      // à droite, c'est la partie domaine
        var pos3 = chaineEmail.lastIndexOf('.');
        if (pos3 < 0)
        {
           return false; // pas de . dans le domaine
        }
        var domaineEmail = chaineEmail.substring(pos2+1, pos3);
        if (domaineEmail == "")
        {
           return false; // il faut un domaine
        }
        if (domaineEmail.length > 17)
        {
           return false; // Au format de l'Etat, le domaine est limité à 17 caractères
        }
        if (!std_verifierStringDansAlphabet(domaineEmail, alphabet))
        {
        	return false; // caractères invalides ?
        }
        
     // à droite après le '.', c'est la partie extension du domaine
        var extensionDomaineEmail = chaineEmail.substring(pos3+1, chaineEmail.length);
        if (extensionDomaineEmail == "")
        {
           return false; // il faut une extension du domaine
        }
        if (!std_verifierStringDansAlphabet(extensionDomaineEmail, alphabet))
        {
           return false; // caractères invalides ?
        }
        if (extensionDomaineEmail.length > 3)
        {
           return false; // Au format de l'Etat, l'extension du domaine est limité à 3 caractères
        }
        
        return true;
}

///////////////////////////////////////////
// Fonctions de traitement de chaînes
///////////////////////////////////////////
///////////////////////////////////////////

function std_remplacerTexte(Chaine,Source,Cible)
{
  if (Source == ".")
  {
     Source = "\\.";
  }
  var expressionReguliere = new RegExp(Source,"ig");
  return Chaine.replace(expressionReguliere, Cible);
}

//** TrimDebut **
// Supprime les espaces se trouvant en début de chaîne.
// Renvoie la chaine traitée
function std_trimDebut(Chaine)
{
  var expressionReguliere = new RegExp("^ +","ig");
  chaineTraitee = Chaine.replace(expressionReguliere, "");
  return chaineTraitee;
}

//** TrimFin **
// Supprime les espaces se trouvant en fin de chaîne.
// Renvoie la chaine traitée
function std_trimFin(Chaine)
{
  var expressionReguliere = new RegExp(" +$","ig");
  chaineTraitee = Chaine.replace(expressionReguliere, "");
  return chaineTraitee;
}


function std_trim(Chaine)
{
  chaineTraitee = std_trimDebut( Chaine );
  chaineTraitee = std_trimFin( chaineTraitee );
  return chaineTraitee;
}

//** TrimDebut **
// Supprime le caractère (2° paramètre) se trouvant en début de chaîne.
// e.g.
//   "aaaab"  ==> "b"
//   "aaaa"   ==> ""
// Renvoie la chaine traitée
function std_trimDebutCaractere(chaine, caractereASupprimer )
{
  chaineTraitee = std_trim(chaine);
  var expressionReguliere = new RegExp("^"+caractereASupprimer+"+","ig");
  chaineTraitee = chaineTraitee.replace(expressionReguliere, "");
   return chaineTraitee ;
}

function std_completerTexteADroite(chaineInitiale, chaineComplementaire, longueurFinale)
{
    while (chaineInitiale.length < longueurFinale)
    {
        chaineInitiale += chaineComplementaire
    }
    return chaineInitiale
}

function std_completerTexteAGauche(chaineInitiale, chaineComplementaire, longueurFinale)
{
    chaineInitiale = ""+chaineInitiale;
    while (chaineInitiale.length < longueurFinale)
    {
        chaineInitiale = chaineComplementaire + chaineInitiale
    }
    return chaineInitiale
}

///////////////////////////////////////////
// Fonctions de Conversion
///////////////////////////////////////////
///////////////////////////////////////////

//** convertirStringToFloat**
// Transforme une valeur chaine en numerique si possible
// sinon retourne NaN
function std_convertirStringToFloat(Chaine)
{
  var nombreFlottant;

  if ( std_verifierNombreDecimal(Chaine) == true)
  {
    chaineNombreSimple = std_remplacerTexte(Chaine, globale_SeparateurMilliers, "");
    chaineNombreSimple = std_remplacerTexte(Chaine, globale_SeparateurDecimal, ".");		
    nombreFlottant = parseFloat(chaineNombreSimple);
  }
  else
  {
    nombreFlottant = NaN;
  }
  return nombreFlottant;
}

// Explication de l'expression reguliere:
// ^ => debut de la chaine
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// / => separateur jour / mois
// [0-9]{1,2} => il y a une suite d'au plus 2 chiffres
// / => separateur mois / annee
// [0-9]{2} => il y a une suite de 2 chiffres pour l'annee
// [0-9]{4} => il y a une suite de 4 chiffres pour l'annee
// ([0-9]{2})|([0-9]{4}) => il y a une suite de 2 ou 4 chiffres pour l'annee
// ((/([0-9]{2})|([0-9]{4})))? => la serie separateur mois / annee + chiffres est present au plus une fois
// $ => fin de la chaine
function std_convertirStringToDate(Chaine, formatDate)
{
  formatDate = formatDate.toLowerCase();

  if (!std_verifierStringDansAlphabet(Chaine, CONSTANTE_ALPHABET_NUMERIQUE + globale_SeparateurDate))
  {
    return null;
  }

  var tableauElementsDate = Chaine.split( globale_SeparateurDate );
  positionJour  = formatDate.indexOf('d',0);
  positionMois  = formatDate.indexOf('m',0);
  positionAnnee = formatDate.indexOf('y',0);
  ordreJour  = 0;
  ordreMois  = 0;
  ordreAnnee = 0;
  decalage = 5;

  if (positionJour < positionMois)
  {
    ordreAnnee = 2;
    ordreJour  = 0;
    ordreMois  = 1;
  }
  else
  {
    ordreAnnee = 2;
    ordreJour  = 1;
    ordreMois  = 0;
  }

  if (positionAnnee < positionJour)
  {  // finalement l'année est au début
    ordreAnnee = 0;
    ordreJour  = ordreJour + 1;
    ordreMois  = ordreMois + 1;
  }

  jour = tableauElementsDate[ordreJour];
  mois = tableauElementsDate[ordreMois];
  annee = tableauElementsDate[ordreAnnee];

  if (typeof(mois) == "undefined")
  {  // ajoute le mois courant s'il n'est pas renseigné
    datejour = new Date();
    mois = datejour.getMonth() + 1; // les mois commencent à 0
  }
  if (typeof(annee) == "undefined")
  {  // ajoute l'année courante si elle n'est pas renseignée
    datejour = new Date();
    annee = datejour.getYear();
    // alert(Chaine + "\n" + annee + " \\ " + datejour )
    if (annee < 1000) // Sous Firefox, 2007 s'affiche 107
    {
      annee = annee + 1900;
    }
  }
  else if (annee.length<=2)
  { // Si l'année est codée sur 1 ou 2 chiffres
    // on la convertit en 4 chiffres
    // le parseInt ne converti pas 08 en 8 mais en 0
    annee = std_trimDebutCaractere(annee, "0" )
    //alert(Chaine + "\n" + annee + " \\ " + parseInt(annee))
    if (parseInt(annee) > globale_AnneePivot)
    {
       annee=parseInt(annee)+1900;
    }
    else
    {
      annee=parseInt(annee)+2000;
    }
  }
  objetDate = new Date(annee, mois-1, jour);
  // en javascript, New Date("32 janvier 2000") ==> "1 février 2000"
  valide = (objetDate.getDate() == jour) && (objetDate.getMonth() == (mois-1)) && (objetDate.getFullYear() == annee)

  if (valide == true)
  {
     return objetDate;
  }
  else
  {
     return null;
  }
}

function std_convertirDateToString(objetDate, codePays)
{
  retour = true;
  parametreValide = true;
  if (arguments.length == 1)
  {
     codePays = globale_codePays;
     parametreValide = true;
  }
  else if (arguments.length == 2)
  {
     parametreValide = true;
  }
  else
  {
    globale_dernierCodeErreur = "SF01" // 01 = mauvais nombre de parametres dans l'appel de la fonction
    parametreValide = false;
  }

  if (parametreValide == true)
  {
    retour = prv_convertirDateToString(objetDate, codePays)
  }
  else
  {
    retour = false;
  }
  return retour;
}

function prv_convertirDateToString(objetDate, codePays)
{
  retour = "";
  if (objetDate != null)
  {
    codePays = codePays.toLowerCase();
    if (codePays == "fr")
    {  // dd/mm/yyyy
      retour = "" + std_completerTexteAGauche(objetDate.getDate(), "0", 2)  + globale_SeparateurDate +
                    std_completerTexteAGauche((objetDate.getMonth()+1), "0", 2) + globale_SeparateurDate + objetDate.getFullYear()
    }  // yyyy/mm/dd
    else if (codePays == "iso")
    {
      retour = "" + objetDate.getFullYear() + globale_SeparateurDate + std_completerTexteAGauche((objetDate.getMonth()+1), "0", 2) + globale_SeparateurDate + std_completerTexteAGauche(objetDate.getDate(), "0", 2)
    } // mm/dd/yyyy
    else if (codePays == "gb")
    {
      retour = "" + std_completerTexteAGauche((objetDate.getMonth()+1), "0", 2) + globale_SeparateurDate +std_completerTexteAGauche(objetDate.getDate(), "0", 2) + globale_SeparateurDate + objetDate.getFullYear()
    }
    else
    {
      globale_dernierCodeErreur = "TS01"; // Valeur de la String incorrecte
      retour = "";
    }
  }
  else
  {
    globale_dernierCodeErreur = "SF10"; // Paramètre null
    retour = "";
  }
  return retour;
}

function std_convertirStringToInteger(Chaine, SeparateurMilliers)
{
  retour = NaN;
  parametreValide = true;
  if (arguments.length == 1)
  {
     SeparateurMilliers = globale_SeparateurMilliers
     parametreValide = true;
  }
  else if (arguments.length == 2)
  {
     parametreValide = true;
  }
  else
  {
     globale_dernierCodeErreur = "SF01" // S = systeme, F = Appel de fonction, 01 = mauvais nombre de parametres dans l'appel de la fonction
     parametreValide = false;
  }

  if (parametreValide == true)
  {
    retour = prv_convertirStringToInteger(Chaine, SeparateurMilliers )
  }
  else
  {
    retour = NaN;
  }
  return retour;
}

function prv_convertirStringToInteger(Chaine, SeparateurMilliers )
{
  retour = NaN;

  ChaineConvertie = std_trimDebutCaractere(Chaine , "0");
  if (ChaineConvertie == "")
  {
    ChaineConvertie = "0";
  }
  if (SeparateurMilliers != CONSTANTE_JAVASCRIPT_SEPARATEUR_MILLIERS)
  {
    ChaineConvertie = std_remplacerTexte(ChaineConvertie,SeparateurMilliers, CONSTANTE_JAVASCRIPT_SEPARATEUR_MILLIERS);
  }


  // On convertie la valeur en integer
  valeurInteger = parseInt(ChaineConvertie);
  if (isNaN(valeurInteger))
  {
      retour = NaN;
  }
  else
  {
      if ((""+valeurInteger) == ChaineConvertie)
      {
        retour = valeurInteger;
      }
      else
      {
        retour = NaN;
      }
  }

  return retour;
}

function std_arrondi(nombre, nombreApresVirgule)
{
  multiplicateur=1;
  for (i=0;i < nombreApresVirgule; i++)
  {
    multiplicateur = multiplicateur*10
  }

  // exemple avec 2 chiffres après la virgule : 3.1485*100=314.85
  // l'arrondi sera exécuté sur ce nombre
  nombre = nombre * multiplicateur;
  // on arrondi le nombre
  resultat=Math.round(nombre);
  
  // on récupère la valeur exacte
  resultat=resultat/multiplicateur;
  
  // ajout de zéro en fonction du nombre de chiffre après la virgule
  // calcul du nombre de zéro à rajouter
  resultat=resultat.toString();
  k = resultat.indexOf('.');
  if ( k!= -1)
  { 
    reste=resultat.substring(k+1,resultat.length).length;
  }
  else 
  { // nombre entier donc on rajoute '.' 
    reste = 0;
    resultat = resultat+'.';
  }
  
  // ajout des zéros
  for (i=reste; i < nombreApresVirgule; i++)
  { 
	   resultat=resultat+0;
  }

  return resultat;
}

//Formatage des dates
function coupe(chaine, separateur) {
// Equivalent a la fonction Split sous VB
	var tab = new Array();
	var element = "";
	var indice = 0;
	
	for (var i = 0; i < chaine.length; i++) {
		var oneChar  =chaine.charAt(i);
		if (oneChar == separateur) {
			tab[indice] = element;
			indice++;
			element = "";
		}
		else element = element + oneChar;
	}
	if (element != "") tab[indice] = element;
	return tab;
}

function quenombre(chaine) {
// La chaine ne contient que des nombres
	for (var i = 0; i < chaine.length; i++) {
		var oneChar = chaine.charAt(i)
		if (oneChar < "0" || oneChar > "9") return false;
	}
	return true;
}

function separe (vardate, separateur) {
// Met la date vardate au format JJ/MM/AAAA
	var tabDate = new Array();
	tabDate = coupe (vardate, separateur);
	if (tabDate.length == 3) {
		annee = tabDate[2];
		if (annee.length == 2) {
			if (parseInt(annee) < 40) annee = "20" + annee
			else annee = "19" + annee;
		}
		else if (annee.length != 4) return "X";
		return tabDate[0]+"/"+tabDate[1]+"/"+annee
	}
	else if (tabDate.length == 1) return "";
	return "X";
}

function std_enleverAutresCaracQueDates(champ) {
	if (!std_verifierStringDansAlphabet(champ.value, CONSTANTE_ALPHABET_NUMERIQUE + globale_SeparateurDate)) {
		champ.value = champ.value.substr(0, champ.value.length - 1);
	}
}

function std_formatageDate (champ) {
	var vardate = champ.value;	
	var nouvelle;
	nouvelle = separe(vardate, "/")
	if (nouvelle == "X") return vardate;
	if (nouvelle == "") {
		nouvelle = separe(vardate, "-");
		if (nouvelle == "X") return vardate;
		if (nouvelle == "") {
			nouvelle = separe(vardate, " ");
			if (nouvelle == "X") return vardate;
			if (nouvelle == "") {
				if (!quenombre(vardate)) return vardate
				if (vardate.length == 6)
					if (vardate.substring(4, 6) < 20)
						nouvelle = vardate.substring(0,2) + "/" + vardate.substring(2,4) + "/20" + vardate.substring(4,6)
					else
						nouvelle = vardate.substring(0,2) + "/" + vardate.substring(2,4) + "/19" + vardate.substring(4,6)
				else 
					if (vardate.length == 8) 
						nouvelle = vardate.substring(0,2) + "/" + vardate.substring(2,4) + "/" + vardate.substring(4,8)
					else if (vardate.length <= 2) {
							var valDate = std_convertirStringToDate(vardate, globale_FormatDate);
							if (valDate != null) {
								champ.value = std_convertirDateToString(valDate,'fr');
								return true; //arrête le traitement
							} else return vardate;
						} else return vardate
			}
		}
	}
	var tab = new Array();
	tab = coupe (nouvelle, "/");
	if (tab[0].length == 1) tab[0] = "0" + tab[0];
	if (tab[1].length == 1) tab[1] = "0" + tab[1];
	nouvelle = tab[0] + "/" + tab[1] + "/" + tab[2];
	champ.value = nouvelle;
}

/**********************************
remplace le alert en ecrivant directement
dans la page
*************************************/	

function printDebug(message, divBgColor, divFontColor) {
	if (!divBgColor || divBgColor=="") divBgColor = "white";
	if (!divFontColor || divFontColor=="") divFontColor = "black";
	var div = document.createElement("div");
	var text = document.createTextNode(message);
	var body = document.getElementsByTagName("body")[0];
	div.style.border= "solid 2px #ECECEC";
	div.style.backgroundColor=divBgColor;
	div.style.color=divFontColor;
	div.style.fontWeight="bold";
	div.style.fontSize="18px";
	div.style.textAlign="center";
	div.appendChild(text);
	body.appendChild(div);
}