var nava = (document.layers);
var iex = (document.all);
var skn = (nava) ? document.topdeck : topdeck.style;
if (nava) document.captureEvents(Event.MOUSEMOVE);
document.onmousemove = get_mouse;

function pop(msg)
{

var content = "<TABLE BORDER=1 CELLPADDING=1 CELLSPACING=0 BORDERCOLOR=#006600 BGCOLOR=#FFFFFF><TR><TD><font color=#000080 size=1>" + msg + "</font></TD></TR></TABLE>";

  if (nava)
  {
	 skn.document.write(content);
	  skn.document.close();
	  skn.visibility = "visible";
  }
	 else if (iex)
  {
	  document.all("topdeck").innerHTML = content;
	  skn.visibility = "visible";
  }
}

function get_mouse(e)
{
	var x = (nava) ? e.pageX : event.x+document.body.scrollLeft;
	var y = (nava) ? e.pageY : event.y+document.body.scrollTop;
	//taille de la fenetre
	var tfen = (nava) ? window.innerHeight : document.body.clientHeight;
	var lfen = (nava) ? window.innerWidth : document.body.clientWidth;

	//taille du calque
	var tlayer = (nava) ? skn.document.height : document.all("topdeck").clientHeight;
	var llayer = (nava) ? skn.document.width : document.all("topdeck").clientWidth;

	if (lfen <(x + llayer+ 20)) {skn.left = x - 10 - llayer} else {skn.left  = x};
	//skn.left = x;

	 if (tfen <(y + tlayer+ 20)) {skn.top = y - 10 - tlayer} else {skn.top	= y+20};
	 //skn.top	= y+20;

}

function kill()
{skn.visibility = "hidden";}

function checkFrame(){
if (self == top) {
top.location.href='./frame.htm?' + self.location;
}
}

// open window general
//     ouvre une fenetre avec URL, nom et taille d&eacute;sir&eacute;s	//
function Ouvre(url,name,param) {
       win=window.open(url,name,param);
       window.win.focus();
}

function MM_displayStatusMsg(msgStr) { //v1.0
  status=msgStr;
  document.MM_returnValue = true;
}

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

function MM_findObj(n, d) { //v3.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document); return x;
}

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

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

////////////////////////////////////////////////////////////
//
//        Affichage   Des   Offres   Détaillées
//
////////////////////////////////////////////////////////////

function AfficherOffre(ref)
{

  var url="./php/DetailOffre.php?NumOffre="+ref;
//alert(url);
  Win=open(url, "OffreAgenceOcean", 'scrollbars=yes,resizable=no,status=no,menubar=no,top=100,left=200,width=800,height=650');
}

function AfficherPhoto()
{
  var ref=GrandePhoto.src;
      PhotoReel = new Image();
      PhotoReel.src=ref;

      hauteur=PhotoReel.height+200;
      largeur=PhotoReel.width+50;

return PhotoReel;
}/************************************************
**     LIBRAIRIE DE FONCTIONS STANDARD SIGMA   **
**	 Fonction de gestion des types	       **
********************************************************************************************
**  version 1.38  - 21/04/2004 - RGUEGAN - modif : bug convertirNombreEntier "01","" renvoyait NaN
**  version 1.37  - 14/01/2004 - RGUEGAN - modif : bug verifNombreEntier "1-1" renvoyait true
**  version 1.36  - 03/11/2003 - RGUEGAN - modif : bug sur convertirStringToInteger, pour les nombres commençant par 0
**  version 1.35  - 12/11/2002 - RGUEGAN - modif : remplacement de . par globale_SeparateurDecimal
**  version 1.34  - 05/11/2002 - RGUEGAN - modif : 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(Chaine, SeparateurMilliers)
{
  valeurInteger = std_convertirStringToInteger(Chaine, SeparateurMilliers);
  if (isNaN (valeurInteger) )
  {
    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_verifierNombreEntier(Chaine, SeparateurMilliers )
}
function prv_verifierNombreEntier(Chaine, SeparateurMilliers)
{
  resultat = false;
  Chaine = std_trimDebut(Chaine);
  Chaine = std_trimFin(Chaine);

//  var re = new RegExp("(^-?[0-9]{1,3}(["+SeparateurMilliers+"][0-9]{3})*?$)|(^-?[0-9][0-9]*$)","ig");
  if (Chaine[0] == "-")
  {
	Chaine = Chaine.substring(0, Chaine.length);
  }
  if (std_verifierStringDansAlphabet(Chaine, CONSTANTE_ALPHABET_NUMERIQUE+SeparateurMilliers))
  {
     resultat = true;
  }
  else
  {
     globale_MessageErreur = "La valeur fournie n'est pas un entier."
     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)
{
}
*/

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

function std_comparerDatesFr(stringDate1, stringDate2)
{
  alert("Ne plus utiliser std_comparerDatesFr ! ");
  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 = CONSTANTE_FORMAT_DATE_FR;
  }

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

}

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;
}

///////////////////////////////////////////
// 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, "");
    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(annee) == "undefined")
  {
    datejour = new Date();
    annee = datejour.getYear();
  }
  else if (annee.length==2)
  { // Si l'année est codée sur 2 chiffres
    // on la convertit en 4 chiffres
    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;
}

/************************************************
**     LIBRAIRIE DE FONCTIONS STANDARD SIGMA   **
**	Fonction de gestion des navigateurs    **
*******************************************************************************
**  Version 1.01 - 13/11/2001 - RGUEGAN - corrections mineures sur les noms des
			       variables mal référencées
**  Version 1.00 -  9/11/2001 - RGUEGAN - Première diffusion de la bibliothèque
**
*******************************************************************************/

///////////////////////////////////////////
// Variables de détection des navigateurs
///////////////////////////////////////////
///////////////////////////////////////////

// isNetscape4 : seul netscape 4 renverra true, les versions supérieurs de netscape renverrons false.
//		e.g. isNetscape4 renverra false pour Netscape 6

// iscompatibleXxx :  indique si le browser est compatible avec la version demandée,
//		e.g. isCompatibleInternetExplorer4 renverra true pour MSIE6

std_isNetscape	= ("Netscape"==navigator.appName)
std_isInternetExplorer	= ("Microsoft Internet Explorer"==navigator.appName)

std_isNetscape4 	   = (document.layers)? true:false
std_isCompatibleNetscape6  = (document.getElementById  && std_isNetscape )? true:false

std_isIE4	     = (document.all && !document.getElementById) ? true:false
std_isCompatibleIE4  = (document.all)? true:false
std_isCompatibleIE55 = (document.getElementById && std_isInternetExplorer)? true:false

std_isDHTML = (std_isNetscape4 || std_isCompatibleNetscape6 || std_isCompatibleIE4 || std_isCompatibleIE55)
std_isDOM   = (std_isCompatibleNetscape6 || std_isCompatibleIE55)

///////////////////////////////////////////
// Fonction d'initialisation
///////////////////////////////////////////
///////////////////////////////////////////

function std_initialiserDOM()
{
  if (std_isIE4 == true)
  {  // Créer la fonction "getElementById" pour IE4
     document.getElementById = function(id)
			       {
				 return document.all[id] || null;
			       }
  }
  else if (std_isNetscape4)
  {  // Fonctionne seulement avec les layers
     document.getElementById = function(id)
			       {
						var lyr = eval("document." + id);
				    // On définit la propriété STYLE pour
				    // être compatible avec les autres navigateurs
							lyr.style = lyr;

						return lyr;
					}
  }
}

///////////////////////////////////////////
// Fonction de manipulation du DOM
///////////////////////////////////////////
///////////////////////////////////////////

function std_getReference(idObjet)
{
  return document.getElementById(idObjet)
}


/*
function setSourceHTML(id, valeur)
{
  if (!std_isNetscape4)
  {
     getReference(id).innerHTML = valeur
  }
  else
  {
      with(document.layers[id].document)
      {
	  open();
	  write(valeur);
	  close();
      }
  }

}
*/

function std_setSourceHTML(referenceObjet, valeur)
{
  if (!std_isNetscape4)
  {
     referenceObjet.innerHTML = valeur
  }
  else
  {
      with(referenceObjet.document)
      {
	  open();
	  write(valeur);
	  close();
      }
  }

}
function std_getSourceHTML(referenceObjet)
{
  return referenceObjet.innerHTML
}

function std_cacherObjet(referenceObjet)
{
  referenceObjet.style.visibility = 'hidden'
}

function std_montrerObjet(referenceObjet)
{
  referenceObjet.style.visibility = 'visible'
}

///////////////////////////////////////////////////////////////////////
// Fonctions d'initialisation appelées automatiquement au chargement
// de la bibliothèque
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
std_initialiserDOM();

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

function SetCookie (name, value) {
// un cookie a besoin d'un nom, d'une valeur, d'un nom de domaine, d'une date d'expiration
//
    var argv=SetCookie.arguments;
    var argc=SetCookie.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=name+"="+escape(value)+
        ((expires==null) ? "" : ("; expires="+expires.toGMTString()))+
        ((path==null) ? "" : ("; path="+path))+
        ((domain==null) ? "" : ("; domain="+domain))+
        ((secure==true) ? "; secure" : "");
}
function GetCookie (name) {
  var arg=name+"=";
  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 getCookieVal(offset) {
  var endstr=document.cookie.indexOf (";", offset);
  if (endstr==-1)
          endstr=document.cookie.length;
  return unescape(document.cookie.substring(offset, endstr));
}

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

function GestionCaracteresSpeciaux(LibelleInit)
{
  var LibelleModif=LibelleInit;
  var reg=new RegExp("'", "g");
  LibelleModif=LibelleModif.replace(reg,"&acute;");
  reg=new RegExp("´", "g");
  LibelleModif=LibelleModif.replace(reg,"&acute;");
  reg=new RegExp('"', 'g');
  LibelleModif=LibelleModif.replace(reg,'&quot;');
  return LibelleModif;
}

///////////////////////////////////////////////////////////////////////////
/**
 * Javascript trim, ltrim, rtrim
 * Fonctions de suppression des espaces surnuméraires (ou autres caractères)
 * en début et en fin de chaine.
 * trim va faire appel à deux autres méthodes rtrim et ltrim qui éventuellement
 * restent accessibles individuellement.
 *
 * Source :  * http://www.webtoolkit.info/
 *
 * @param   {String}  str       Chaine de caractères à traiter.         OBLIGATOIRE
 * @param   {String}  chars     Chaine à supprimer (par défaut, espace) FACULTATIF
 * @return  {String}
 */
function trim (str, chars)
{
    return ltrim(rtrim(str, chars), chars);
}

function ltrim (str, chars)
{
    var car = (chars != undefined) ? chars : "\\s";
    return str.replace(new RegExp("^[" + car + "]*", "g"), "");
}

function rtrim (str, chars)
{
    var car = (chars != undefined) ? chars : "\\s";
    return str.replace(new RegExp("[" + car + "]*$", "g"), "");
}

function get_length(txt,NomId,Maxi)
{
	if (txt.length > Maxi)
	{
	txt = txt.substring(0,Maxi);
	document.getElementById(NomId).value = txt;
	alert('Vous ne pouvez pas insérer plus de '+Maxi+' caractères.');
	}
}

function AffichePlan(val){

//alert(document.getElementById('D_PLAN').style.zIndex);

   if (val == '1' )
      document.getElementById('D_PLAN').style.zIndex = '2000';
   else {

      document.getElementById('D_PLAN').style.zIndex = '-2000';
    }
}

function AffichePrix(val){
      document.getElementById(val).style.display = '';
}

function CachePrix(val){
      document.getElementById(val).style.display = 'none';
}