// JavaScript Document

//********************************************************
// Ajoute la fonction trim comme méthode de l'objet String.
//********************************************************
String.prototype.trim = function()
{
  var ExpReg = new RegExp("(^\\s*)|(\\s*$)", "g");
  return this.replace(ExpReg, "");
}

//********************************************************
// Ajoute la fonction toUpperWords comme méthode de l'objet String.
//********************************************************
String.prototype.toUpperWords = function()
{
  var Maj;
  var Chaine = this;
  var ExpReg = new RegExp("^[a-z]|[ -][a-z]", "g");
  var tabChaines = Chaine.match(ExpReg);
  if(tabChaines == null) return this;
  for(i = 0; i < tabChaines.length; i++)
  {
    Maj = tabChaines[i].toUpperCase();
    Chaine = Chaine.replace(tabChaines[i], Maj);
  }
  return Chaine;
}

//********************************************************
//Cette fonction décrypte une chaine de caractères
//********************************************************
function Decrypter(Chaine)
{
	// On enlève un caractère sur 2
	var temp = "";
	for (i = 0; i < Chaine.length; i++)
	{
		if((i % 2) == 0)
			temp += Chaine.charAt(i);
	}
	// Remplacement de(s) l'arobase(s) et des points
	temp = temp.replace(/=/g, "@");
	temp = temp.replace(/%/g, ".");
	var result = "";
	// Inversement de la chaine
	for (i = temp.length; i >= 0 ; i--)
		result += temp.charAt(i);
	
	return result;
}

//********************************************************
//Cette fonction affiche un lien vers un e-mail décrypté
//********************************************************
function AfficherMel(Chaine, Titre, Libelle, Classe)
{
	var temp = Decrypter(Chaine);
	if(Libelle == undefined || Libelle == "")   Libelle = temp;
	Libelle = Libelle.replace(/&lt;/g, "<");

	if(Classe == undefined)   Classe = "";
	
	var Chaine = '<' + 'a href="mailto:' + temp + '" title="' + Titre + '" class="' + Classe + '">' + Libelle + '<' + '/a>';
    
  document.write(Chaine);
}

//********************************************************
// Modification du "Display" d'un objet : none ou block
//********************************************************
function displayDiv(id, DisplayType) 
{
	var CurDiv = document.getElementById(id); 
	if(CurDiv != undefined)
    CurDiv.style.display = DisplayType; 
}

//********************************************************
// Bascule l'affichage d'un onglet courant (nom stocké dans la variable "idCurTab") 
// vers un autre avec mémorisation de l'onglet affiché
// Si LostFocus vaut "1", on bascule le focus vers un lien invisible dont l'id est "blur"
//********************************************************
function SwapTab(idTab, LostFocus)
{
	var OldTab = document.getElementById(idCurTab); 
	OldTab.className = "normal";
	var NewTab = document.getElementById(idTab); 
	if(NewTab != undefined)
	{
		NewTab.className = "current";
		idCurTab = idTab;
	}
	if(LostFocus == true)
	  document.getElementById("blur").focus();
}

//********************************************************
// Bascule l'affichage d'un div courant (nom stocké dans la variable "IdCurDiv") 
// vers un autre avec mémorisation du calque affiché
//********************************************************
function SwapDiv(IdDiv)
{
	if(IdDiv != idCurDiv)
	{
		displayDiv(idCurDiv, "none");
		displayDiv(IdDiv, "block");
		idCurDiv = IdDiv;
	}
}

//********************************************************
//Cette fonction modifie les paramêtres du formulaire de gestion
//et lance le traitement du formulaire
//********************************************************
function LancerAdm(NomForm, Verbe, Valider, AncreInterne)
{
  TheForm = document.getElementById(NomForm);
	TheForm.Action.value = Verbe;
	
	var bEnvoyer = true;
	var bConfirmer = true;
	if (Valider == false || Valider == undefined) 
		bConfirmer = false;
	
	if (bConfirmer)
	{
		if (! confirm("Confirmez-vous cette action : " + Verbe.toUpperCase() + " ?"))
			bEnvoyer = false;
	}
	
	if(AncreInterne != "" && AncreInterne != undefined)	
		TheForm.action = TheForm.action + "#" + AncreInterne;
	
	if(bEnvoyer)	TheForm.submit();
}

//********************************************************
// Cette fonction supprime le contenu des champs indiqués et se positionne sur le premier
// Pour les checkbox, radio et les select, on utilise l'argument suivant comme valeur
//********************************************************
function Vider()
{
  var CurArg; //Numéro de l'argument en cours
  var CurObj; // Objet en cours
  var argLength = Vider.arguments.length;
  for(CurArg = 0; CurArg < argLength; CurArg++) 
  {
    CurObj = document.getElementById(Vider.arguments[CurArg]);
    // Traitement différent selon le type d'élément
    if(CurObj.type)
    {
      // Eléments de formulaire
      switch(CurObj.type)
      {
        case "checkbox":
        {
          CurObj.checked = Vider.arguments[++CurArg];
          break;
        }
        case "radio":
        {
          CurObj.checked = Vider.arguments[++CurArg];
          break;
        }
        case "select-one":
        case "select-multiple":
        {
          CurObj.selectedIndex = Vider.arguments[++CurArg];
          break;
        }
        default: // "text", "hidden", "textarea"
        {
          CurObj.value = "";
          break;
        }
      }
    }
    else  // Eléments normaux
    {
      if(CurObj.firstChild)
        CurObj.removeChild(CurObj.firstChild);
    }
  }
  // Positionnement sur le premier élément de la liste
  document.getElementById(Vider.arguments[0]).focus();
}

//================================================================
// Fonction supprimant les caractères "px" de la fin propriété de positionnement (left, top...)
//----------------------------------------------------------------------------------------------------------------
// Paramètres :
//	- Propriete (string) : propriété à "nettoyer"
//----------------------------------------------------------------------------------------------------------------
// Retourne la valeur numérique de la propriété
//================================================================
function SupprimerPX(Propriete)
{
	alert("SupprimerPX : Type = " + typeof(Propriete) + " - Propriété = " + Propriete + " - Number(Propriété) = " + Number(Propriete));
	// Si la propriété n'est pas une chaine, elle ne peut contenir "px"
	if(typeof(Propriete) != "string") return Number(Propriete);
	
	if(Propriete.substring( Propriete.length - 2 ) == "px")
		return Number( Propriete.substring( 0, Propriete.length - 2 ) );
	else
		return Propriete;
}

//=============================================================================================
// Fonction permettant de récupérer une propriété de style qu'il soit "in line" ou "css"
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Element (objet ou string) : élément dont la propriété de style est recherchée
//	- Propriete (string) : chaine indiquant la propriété à retourner
//
// Elle accepte, comme "Element", un objet ou son ID
//---------------------------------------------------------------------------------------------
// Retourne la valeur de la propriété de style
//=============================================================================================
function GetStyle(Element, Propriete)
{
	//alert("GetStyle : Element = " + Element + " - Type = " + typeof(Element) + " - Propriété = " + Propriete);
	// On regarde s'il s'agit d'un objet ou de son ID
	if(typeof(Element) == "object")
		var CurElement = Element;
	else
		var CurElement = document.getElementById(Element);

	var CptedStyle = CurElement.currentStyle || window.getComputedStyle(CurElement, null);
	return SupprimerPX(CptedStyle[Propriete]);
}

//=============================================================================================
// Fonction permettant de définir une propriété de style
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Element (objet ou string) : élément dont la propriété de style est modifiée
//	- Propriete (string) : chaine indiquant la propriété concernée
//	- Valeur (variable) : valeur à affecter à la propriété
//
// Elle accepte, comme "Element", un objet ou son ID
//=============================================================================================
function SetStyle(Element, Propriete, Valeur)
{
	// On regarde s'il s'agit d'un objet ou de son ID
	if(typeof(Element) == "object")
		var CurStyle = Element.style;
	else
		var CurStyle = document.getElementById(Element).style;
		
  CurStyle[Propriete] = Valeur;
}

//=============================================================================================
// Fonction permettant de récupérer l'objet "event" sur différents navigateurs
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Evenement (objet) : évènement
//---------------------------------------------------------------------------------------------
// Retourne l'évènement
//=============================================================================================
function GetEvent(Evenement)
{
	if( document.all )
		return event;
	else
		return Evenement;
}

//=============================================================================================
// Création d'un élément via DOM
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Parent (objet ou string) : Elément parent ou son id
//	- TypeTag (string) : Type de balise à créer
// Facultatifs :
//	- Attributs (tableau) : Tableau des attributs sous la forme {nom, valeur, nom, valeur, ...}
//	- Texte (string) : Contenu de type texte de la balise
//	- First (booléen) : Si "true", l'élément doit être créé en tant que FirstChild
//
// Elle accepte, comme "Parent", un objet ou son ID
//---------------------------------------------------------------------------------------------
// Retourne l'élément créé
//=============================================================================================
function CreateTag(Parent, TypeTag, Attributs, Texte, First)
{
  // Eléments facultatifs
  if(Attributs == undefined) Attributs = null;
  if(Texte == undefined) Texte = "";
  if(First == undefined) First = false;
  // Création de l'élément
  var NewTag = document.createElement(TypeTag);
  // Création de ses attributs
  if(Attributs != null)
  {
    for(i = 0; i < Attributs.length; i++)
    {
      // Gestion différente pour la classe
      if(Attributs[i] == "class")
        DomSetClass(NewTag, Attributs[++i]);
      else
        NewTag.setAttribute(Attributs[i], Attributs[++i]);
    }
  }
  // Affectation du contenu
  if(Texte != "")
    NewTag.appendChild(document.createTextNode(Texte));
  
  // Ajout de l'élément au parent
 	ObjParent = (typeof(Parent) == "object")? Parent : document.getElementById(Parent);
  if(First && ObjParent.firstChild)
    ObjParent.insertBefore(NewTag, ObjParent.firstChild);
  else
    ObjParent.appendChild(NewTag);
  
  return NewTag;
}

//=============================================================================================
// Suppression d'un élément via DOM
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- IdParent (string) : Identifiant de l'élément parent
//	- IdTag (string) : Identifiant de l'élément à supprimer
//=============================================================================================
function DeleteTag(IdParent, IdTag)
{
  Parent = document.getElementById(IdParent);
  Element = document.getElementById(IdTag);
  // Suppression (s'il existe)
  if(Element != null)
    Parent.removeChild(Element);
}

//=============================================================================================
// Modification d'un attribut d'un élément via DOM
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- IdTag (string) : Identifiant de l'élément
//	- Attribut (string) : Nom de l'attribut à modifier
//	- Valeur (string) : Nouvelle valeur
//=============================================================================================
function ChangeAttribut(IdTag, Attribut, Valeur)
{
  Element = document.getElementById(IdTag);
  // Modification
  Element.setAttribute(Attribut, Valeur);
}

// Cette fonction modifie la valeur d'un tag par une donnée unique
function DomChangeData(Source, Element, NomTag)
{
  var Item = Source.getElementsByTagName(NomTag)[0];
  var Valeur = (Item.firstChild)? Item.firstChild.nodeValue : "";
  CurObj = document.getElementById(Element);
  // Traitement différent selon le type d'élément
  if(CurObj.type)
  {
    // Eléments de formulaire
    switch(CurObj.type)
    {
      case "checkbox":
      {
        CurObj.checked = (Valeur == 1)? "checked" : "";
        break;
      }
      case "select-one":
      case "select-multiple":
      {
        CurObj.value = Valeur;
        break;
      }
      default:  // "text", "hidden", "textarea"
      {
        CurObj.value = Valeur;
        break;
      }
    }
  }
  else  // Eléments normaux
  {
    if(CurObj.firstChild)
      CurObj.firstChild.nodeValue = Valeur;
    else
      CurObj.appendChild(document.createTextNode(Valeur));
  }
}

// Cette fonction récupère une donnée unique
function DomGetData(Source, NomTag)
{
  var Item = Source.getElementsByTagName(NomTag)[0];
  if(Item.firstChild)
    return Item.firstChild.nodeValue;
  else
    return "";
}

// Cette fonction récupère un attribut
function DomGetAttribute(Source, NomAttribut)
{
  return Source.getAttribute(NomAttribut);
}

// Cette fonction affecte la classe à lélément (Syntaxe différente sous IE)
function DomSetClass(Source, Classe)
{
  if(document.all)  // IE
    Source.setAttribute("className", Classe);
  else              // Autres
    Source.setAttribute("class", Classe);
}

// Cette fonction supprime tout le contenu d'un élément source (tous ses noeuds)
// Elle recoit l'objet ou son id
function DomDeleteTree(Source)
{
  if(typeof(Source) == "string")
    Source = document.getElementById(Source);
  while (Source.firstChild)
    Source.removeChild(Source.firstChild);
}

// Cette fonction recolorie les ligne d'un tableau
function RecolorierTableau(IdTableau, Ligne1, Ligne2)
{
  var Item;
  var Tab = document.getElementById(IdTableau);
  // On récupère le TBody
  CurTBody = Tab.firstChild;
  // On vérifie d'abord si l'objet a des enfants
  if (CurTBody.hasChildNodes())
  {
    var bLigne = true;
    // Récupération des éléments de type "TR"
    var collEnfants = CurTBody.getElementsByTagName("TR");
    for (var i = 0; i < collEnfants.length; i++) 
    {
      // Modification de la classe
      collEnfants[i].className = (bLigne)? Ligne1 : Ligne2;
      bLigne = !bLigne;
    }
  }
}

// Cette fonction indique la valeur du bouton radio coché dans le groupe demandé
function WhichRadio(Nom)
{
  // Recherche des objets de type "input"
  var Inputs = document.getElementsByTagName('input');
  for(i = 0; i < Inputs.length; i++)
  {
    // filtre sur les radios
    if(Inputs[i].type == "radio")
    {
      // Filtre sur le bouton radio recherché et vérification de son état
      if(Inputs[i].name == Nom && Inputs[i].checked)
        return Inputs[i].value;
    }
  }
  return "none";
}

// Cette fonction coche le bouton radio ayant la valeur demandé
// Si la valeur est vide, tous les boutons radio sont décochés
function SetRadio(Nom, Valeur)
{
  // Recherche des objets de type "input"
  var Inputs = document.getElementsByTagName('input');
  for(i = 0; i < Inputs.length; i++)
  {
    // filtre sur les radios
    if(Inputs[i].type == "radio")
    {
      // Filtre sur le bouton radio recherché et sa valeur
      if(Inputs[i].name == Nom)
      {
        if(Valeur == "")    // Tout doit être décoché
          Inputs[i].checked = false;
        else if(Inputs[i].value == Valeur)  // On coche la valeur demandée
          Inputs[i].checked = "checked";
      }
    }
  }
}

//=============================================================================================
// Vérification d'un format
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Input (objet) : Objet à valider (this)
//  - Type (string) : Type de teste à effectuer ("date", "heure", "email"...)
//  - Texte (string) : Chaine qui sera insérée dans les messages
//  - Obligatoire (booléen) : Indique si une saisie est obligatoire (vrai par défaut)
//---------------------------------------------------------------------------------------------
// Cette fonction vérifie que la saisie est au format demandé
//---------------------------------------------------------------------------------------------
// Elle retourne true ou false selon le résultat
//=============================================================================================
function CheckValue(Input, Type, Texte, Obligatoire)
{
  var Valeur = Input.value;
  var ExpReg;
  if(Obligatoire == undefined) Obligatoire = true;
  // S'il n'y a pas de valeur à tester, on arrête
  if(Obligatoire && Valeur == "")
  {
    alert(Texte + " est obligatoire !");
    return false;
  }
  else if(Valeur != "")
  {
    switch(Type)
    {
    case "date":  // jj/mm/aa ou jj/mm/aaaa
      if(!isDate(Valeur))
      {
        alert("Le format de " + Texte + " n'est pas valable !\n\nFormats acceptés : jj/mm/aa ou jj/mm/aaaa.");
        return false;
      }
      break;
    case "heure":  // hh:mm
      ExpReg = new RegExp("^\\d{2}:\\d{2}$");
      if(!ExpReg.test(Valeur))
      {
        alert("Le format de " + Texte + " n'est pas valable !\n\nFormat accepté : hh:mm.");
        return false;
      }
      break;
    case "telephone":  // 0(1-8).xx.xx.xx.xx, séparateur ".- "
      ExpReg = new RegExp("^0[0-8][ .-]?(\\d{2}[ .-]?){4}$");
      if(!ExpReg.test(Valeur))
      {
        alert("Le format du numéro " + Texte + " n'est pas valable !\n\nFormat accepté : (01 à 08).xx.xx.xx.xx\nSéparateurs acceptés : rien, point, tiret ou espace.");
        return false;
      }
      break;
    case "email":  // xxx.xxx-xxx@xxx-xxx.xx.xxx
      ExpReg = new RegExp("^[a-z][_a-z0-9-]*(\\.[_a-z0-9-]+)*@[a-z0-9-]+[_a-z0-9-]*(\\.[_a-z0-9-]+)*\\.[a-z]{2,3}$");
      if(!ExpReg.test(Valeur))
      {
        alert("L'adresse mail " + Texte + " n'est pas valable !\n\nFormat accepté : xxx[.-_]xxx[.-_]xxx@xxx[.-_]xxx[.-_]xx.xx(x) en minuscule.");
        return false;
      }
      break;
    case "entier":  // que des chiffres
      if(Valeur != parseInt(Valeur))
      {
        alert("Le format du " + Texte + " n'est pas valable !\n\nCe doit être un entier.");
        return false;
      }
      break;
    default:
      break;
    }
  }
  return true;
}

//=============================================================================================
// Application d'un format
//---------------------------------------------------------------------------------------------
// Paramètres :
//	- Chaine (string) : Chaine à formater
//  - Type (string) : Type de format à appliquer ("date", "heure", "email"...)
//---------------------------------------------------------------------------------------------
// Cette fonction applique un format à la chaine reçue
//---------------------------------------------------------------------------------------------
// Elle retourne la chaine modifiée
//=============================================================================================
function Format(Chaine, Type)
{
  var Temp = Chaine;
  var ExpReg;
  // S'il n'y a pas de valeur à tester, on arrête
  if(Chaine != "")
  {
    switch(Type)
    {
    case "telephone":  // xx xx xx xx xx
      Temp = Temp.replace(/(\d{2})/g, "$1 ");
      // Suppression du point en trop
      return Temp.substr(0, Temp.length - 1);
      break;
    default:
      break;
    }
  }
  return Chaine;
}

function isDate(CurDate) 
{
  // Cette fonction permet de vérifier la validité d'une date au format jj/mm/aa ou jj/mm/aaaa
  if (CurDate == "") return false;
  
  Expression = new RegExp("^\\d{1,2}\/\\d{1,2}\/(\\d{2}|\\d{4})$");
  // On teste l'expression régulière pour valider la forme de la date
  if (!Expression.test(CurDate)) return false;
  
  // On sépare la date en 3 variables pour vérification
  Jour = parseInt(CurDate.split("/")[0], 10);
  Mois = parseInt(CurDate.split("/")[1], 10);
  Annee = parseInt(CurDate.split("/")[2], 10);
  
  // Si l'année n'est composée que de 2 chiffres on complète automatiquement
  if (Annee < 1000) 
  {
    // Si Annee < 89 alors on ajoute 2000 sinon on ajoute 1900
    if (Annee < 89) Annee+=2000;
    else Annee+=1900;
  }
  
  // Définition du dernier jour de février
  // Année bissextile si divisible par 4 et pas un siècle, ou bien si divisible par 400
  if (Annee%4 == 0 && Annee%100 !=0 || Annee%400 == 0) 
    MaxFev = 29;
  else 
    MaxFev = 28;
  
  // Nombre de jours pour chaque mois
  nbJours = new Array(31,MaxFev,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 ( Mois >= 1 && Mois <=12 && Jour >= 1 && Jour <= nbJours[Mois-1] );
}