// -------------------------------------------------------------------
// outilsGlobaux.js
// -------------------------------------------------------------------

// -------------------
// VARIABLES GLOBALES
// -------------------


//----------------------------------------------------------------------
// Traite la demande suivante 'estNombre'
// Verifie que la chaine ne contient que des chiffres
//
// Parametres :
//    - pChaine : chaine a traiter
// Valeur retournee : booleen
//----------------------------------------------------------------------
function estNombre (pChaine){
   var exp = new RegExp("^[0-9-.]*$","g");
   return exp.test(pChaine);
}


//----------------------------------------------------------------------
// Traite la demande suivante 'isArray'
// Verifie que le parametre est un tableau
//
// Parametres :
//    - pElement : element a traiter
// Valeur retournee : booleen
//----------------------------------------------------------------------
function isArray(pElement) {
    return isObject(pElement) && pElement.constructor == Array;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'isObject'
// Verifie que le parametre est un objet
//
// Parametres :
//    - pElement : element a traiter
// Valeur retournee : booleen
//----------------------------------------------------------------------
function isObject(pElement) {
    return (pElement && typeof pElement == 'object') || isFunction(pElement);
}

//----------------------------------------------------------------------
// Traite la demande suivante 'isFunction'
// Verifie que le parametre est une fonction
//
// Parametres :
//    - pElement : element a traiter
// Valeur retournee : booleen
//----------------------------------------------------------------------
function isFunction(pElement) {
    return typeof pElement == 'function';
}

//----------------------------------------------------------------------
// Traite la demande suivante 'isString'
// Verifie que le parametre est une chaine
//
// Parametres :
//    - pElement : element a traiter
// Valeur retournee : booleen
//----------------------------------------------------------------------
function isString(pElement) {
    return typeof pElement == 'string';
}

//----------------------------------------------------------------------
// Traite la demande suivante 'deselectionne'
// Deselectionne les elements nommes par 'nomElements'
//
// Parametres :
//    - nomElements : nom des elements
// Valeur retournee : booleen
//----------------------------------------------------------------------
function deselectionne (nomElements) {
   listeElements = document.getElementsByName(nomElements);
   for (var i = 0 ; i < listeElements.length ; i++) {
      listeElements[i].checked = '';
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'selectionneId'
// Selectionne l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function selectionneId (idElement) {
   element = document.getElementById(idElement);
   element.checked = 'checked';
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'metValeur'
// Met la valeur d'un element identifie par 'idElement' a 'valeur'
//
// Parametres :
//    - idElement : identifiant de l'element
//    - valeur : nouvelle valeur de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function metValeur (idElement, valeur) {
   element = document.getElementById(idElement);
   element.value = valeur;
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'metValeurParNom'
// Met la valeur d'elements nommes 'nomElements' a 'valeur'
//
// Parametres :
//    - nomElements : noms des elements
//    - valeur : nouvelle valeur des elements
// Valeur retournee : booleen
//----------------------------------------------------------------------
function metValeurParNom (nomElements, valeur) {
   listeElements = document.getElementsByName(nomElements);
   for (var i = 0 ; i < listeElements.length ; i++) {
      listeElements[i].value = valeur;
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'metLibelleSelectionne'
// Met la valeur d'un element identifie par 'idElement' au libelle de
// l'option selectionne dans la liste 'liste'
//
// Parametres :
//    - idElement : identifiant de l'element
//    - liste : liste dont on recupere le libelle de l'option selectionne
// Valeur retournee : booleen
//----------------------------------------------------------------------
function metLibelleSelectionne (liste, idElement) {
   var valeur = '';
   if (document.getElementById(liste))
      liste = document.getElementById(liste);
   valeur = liste.options[liste.options.selectedIndex].text;
   return metValeur(idElement, valeur);
}

//----------------------------------------------------------------------
// Traite la demande suivante 'soumissionFormulaire'
// Soumet le formulaire dont l'identifiant est passe en parametre
//
// Parametres :
//    - idFormulaire : identifiant du formulaire à soumettre
// Valeur retournee : neant
//----------------------------------------------------------------------
function soumissionFormulaire (idFormulaire) {
   formulaire = document.getElementById(idFormulaire);
   formulaire.submit();
}

//----------------------------------------------------------------------
// Traite la demande suivante 'soumissionFormulaireNCaracteres'
// Soumet le formulaire dont l'identifiant est passe en parametre quand
// l'element identifie par 'idElement' est constitue de 'nbCaracteres' caracteres
//
// Parametres :
//    - idFormulaire : identifiant du formulaire à soumettre
//    - idElement : identifiant de l'element dont on doit compter le nombre
// de caracteres
//    - nbCaracteres : nombre de caracteres pour la soumission
// Valeur retournee : neant
//----------------------------------------------------------------------
function soumissionFormulaireNCaracteres (idFormulaire, idElement, nbCaracteres) {
   if (compteCaracteres(idElement) >= nbCaracteres) {
      document.getElementById(idElement).value = document.getElementById(idElement).value.substr(0,5);
      formulaire = document.getElementById(idFormulaire);
      formulaire.submit();
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'compteCaracteres'
// Compte le nombre de caracteres que contient l'element 'element'
//
// Parametres :
//    - element : element ou identifiant de l'element
// Valeur retournee : entier
//----------------------------------------------------------------------
function compteCaracteres (element) {
   if (document.getElementById(element)) {
      element = document.getElementById(element);
   }

   if (element.nodeName.toLowerCase() == 'input'
         || element.nodeName.toLowerCase() == 'textarea') {
      // si l'element est un champs de formulaire
      return element.value.length;
   } else if (element.innerHTML) {
      // si l'element a un contenu (toutes les balises HTML)
      return element.innerHTML.length;
   } else {
      return 0;
   }
}

//----------------------------------------------------------------------
// Traite la demande suivante 'limiteNbCaracteres'
// Ecrit le nombre de caracteres de l'element 'elementALimiter' dans l'element
// 'idElementAEcrire'
//
// Parametres :
//    - elementALimiter : element (ou identifiant de l'element) dont on limite
//                        le nombre de caracteres
//    - nbMaxCaracteres : nombre de caractère maximum
// Valeur retournee : booleen
//----------------------------------------------------------------------
function limiteNbCaracteres (elementALimiter, nbMaxCaracteres) {
   // Calcul le nombre de caracteres de l'element a limiter
   nbCaracteres = compteCaracteres(elementALimiter);

   if (nbCaracteres > nbMaxCaracteres) {
      // On conserve uniquement les nbMaxCaracteres premiers caracteres
      if (document.getElementById(elementALimiter)) {
         elementALimiter = document.getElementById(elementALimiter);
      }
      if (elementALimiter.tagName.toLowerCase() == 'input'
            || elementALimiter.tagName.toLowerCase() == 'textarea') {
         // si l'element est un champs de formulaire
         elementALimiter.value = elementALimiter.value.substr(0, nbMaxCaracteres);
      } else if (elementALimiter.innerHTML) {
         // si l'element a un contenu (toutes les balises HTML)
         elementALimiter.innerHTML = elementALimiter.innerHTML.substr(0, nbMaxCaracteres);
      }
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'afficheElement'
// Affiche l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function afficheElement (idElement) {
   element = document.getElementById(idElement);
   // Affiche l'element en fonction de son type
   // Cas IE
   if (document.all) {
      element.style.display = 'block';
   } else if (element.nodeName.toLowerCase() == 'td') {
      element.style.display = 'table-cell';
   } else if (element.nodeName.toLowerCase() == 'tr') {
      element.style.display = 'table-row';
   } else {
      element.style.display = 'block';
   }

   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'videChamp'
// Vide l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function videChamp (idElement) {
   element = document.getElementById(idElement);
   if (element.nodeName.toLowerCase() == 'input'
         || element.nodeName.toLowerCase() == 'textarea'
         || element.nodeName.toLowerCase() == 'select') {
      // si l'element est un champs de formulaire
      element.value = '';
   } else if (element.innerHTML) {
      // si l'element a un contenu (toutes les balises HTML)
      element.innerHTML = '';
   } else {
      return false;
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'supprimeOption'
// Supprime les options de l'element 'element' ou identifie par 'element'
//
// Parametres :
//    - element : element ou identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function supprimeOption (element) {
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (element.options) {
      for (var i = 0 ; i < element.options.length ; i++) {
         if (element.options[i].value != '') {
            element.options[i] = null;
            i--;
         }
      }
   }
}

//----------------------------------------------------------------------
// Traite la demande suivante 'ajouteOption'
// Ajoute une option a l'element 'element' ou identifie par 'element'
//
// Parametres :
//    - element : element ou identifiant de l'element
//    - texte : texte de l'option
//    - valeur : value de l'option
// Valeur retournee : booleen
//----------------------------------------------------------------------
function ajouteOption (element, texte, valeur) {
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (element.options) {
      element.options[element.options.length] = new Option(texte, valeur);
   }
}

//----------------------------------------------------------------------
// Traite la demande suivante 'cacheElement'
// Cache l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function cacheElement (idElement) {
   element = document.getElementById(idElement);
   // Cache l'element
   element.style.display = 'none';

   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'bloqueElement'
// Bloque l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function bloqueElement (idElement) {
   element = document.getElementById(idElement);
   // Bloque l'element
   element.disabled = true;

   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'debloqueElement'
// Debloque l'element identifie par 'idElement'
//
// Parametres :
//    - idElement : identifiant de l'element
// Valeur retournee : booleen
//----------------------------------------------------------------------
function debloqueElement (idElement) {
   element = document.getElementById(idElement);
   // Debloque l'element
   element.disabled = false;

   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'formateNombre'
// Format le nombre passe en parametre sous le format x xxx,xxxx ('nbChiffres'
// chiffres apres la virgule)
//
// Parametres :
//    - nombre : nombre a formater
//    - nbChiffres : nombre de chiffres apres la virgule
// Valeur retournee : nombre formate
//----------------------------------------------------------------------
function formateNombre (nombre, nbChiffres) {
   // Separe les deux parties du nombre
   nombre = parseFloat(nombre);
   partieEntiere = Math.floor(nombre);
   partieFloattante = nombre - partieEntiere;
   
   // Garde 'nbChiffres' chiffres apres la virgule
   partieFloattante = partieFloattante.toFixed(nbChiffres);
   
   // Formate la partie entiere
   partieEntiere = partieEntiere.toString();
   partieEntiereTmp = '';
   for (var i = partieEntiere.length; i > 0 ; i--) {
      pos = partieEntiere.length - i;
      if (pos != 0 && pos % 3 == 0) {
         partieEntiereTmp = ' ' + partieEntiereTmp;
      }
      partieEntiereTmp = partieEntiere.charAt(i-1) + partieEntiereTmp;
   }
   partieEntiere = partieEntiereTmp;
   
   // Formate la partie floattante
   partieFloattante = partieFloattante.toString();
   partieFloattante = partieFloattante.substring(partieFloattante.indexOf('.')+1, partieFloattante.length);
   
   // Racroche les parties
   nombre = partieEntiere;
   if (nbChiffres != 0) {
      nombre += ',' + partieFloattante;
   }
   
   return nombre;
}


//----------------------------------------------------------------------
// Traite la demande suivante 'verifMail'
// Verifie le format de l'adresse mail passée en paramètre
//
// Parametre :
//    - adresse : adresse mail à vérifier
// Valeur retournee : true (format mail valide) ou false (format mail invalide)
//----------------------------------------------------------------------
function verifMail(adresse)
{
	var place = adresse.indexOf("@",1);
	var point = adresse.indexOf(".",place+1);
	if ((place > -1)&&(adresse.length >2)&&(point > 1)){
		return(true);
	}
	else{
		return(false);
	}
}



//----------------------------------------------------------------------
// Verifie le format de la date passée en paramètre
// Format attendu : JJ/MM/AAAA
// Parametre :
//    - value : date à vérifier
// Valeur retournee : true (format date valide) ou false (format date invalide)
//----------------------------------------------------------------------
function verifDate(value)
{
	if (value == '') // si la variable est vide on retourne faux 
	{
		return false; 
	}	
    
	e = new RegExp("^[0-9]{1,2}\/[0-9]{1,2}\/([0-9]{2}|[0-9]{4})$"); 

	if (!e.test(value)) // On teste l'expression régulière pour valider la forme de la date 
	{
		return false; // Si pas bon, retourne faux 
	}	

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

	// Si l'année n'est composée que de 2 chiffres on complète automatiquement 
	if (a < 1000) 
	{ 
		return false;
	}

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

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

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

//----------------------------------------------------------------------
// Traite la demande suivante 'ouvrirPopup'
// Ouvre une popup ayant pour url 'url', de titre 'titre' et dont les
// parametres de la fenetre sont dans 'parametres'
//
// Parametres :
//    - url : url de la popup
//    - titre : titre de la popup
//    - parametres : tableau de parametres
// Valeur retournee : booleen
//----------------------------------------------------------------------
function ouvrirPopup(url, titre, parametres) {
   // Initialisation des valeurs
   var apparence = '';
   var appHeight = 200;
   var appWidth = 500;
   var appToolbar = 'no';
   var appMenubar = 'no';
   var appScrollbars = 'no';
   var appResizable = 'no';
   var appLocation = 'no';
   var appDirectories = 'no';
   var appStatus = 'no';
   
   // Transforamtion de la chaine parametres en tableau
   if (parametres && !isArray(parametres)) {
      var tmpParametres = parametres.split(",");
      parametres = new Array();
      for (i=0; i<tmpParametres.length; i++) {
         var tmpParametresSplit = tmpParametres[i].split("=");
         parametres[tmpParametresSplit[0]] = tmpParametresSplit[1];
      }
   }

   // Recuperation des valeurs issus de paramteres
   if (parametres) {
      if (parametres['height'])
         appHeight = parametres['height'];
      if (parametres['width'])
         appWidth = parametres['width'];
      if (parametres['toolbar'])
         appToolbar = parametres['toolbar'];
      if (parametres['menubar'])
         appMenubar = parametres['menubar'];
      if (parametres['scrollbars'])
         appScrollbars = parametres['scrollbars'];
      if (parametres['resizable'])
         appResizable = parametres['resizable'];
      if (parametres['location'])
         appLocation = parametres['location'];
      if (parametres['directories'])
         appDirectories = parametres['directories'];
      if (parametres['status'])
         appStatus = parametres['status'];
   }

   // Creation de la variable d'apparence
   apparence += 'height=' + appHeight;
   apparence += ', width=' + appWidth;
   apparence += ', toolbar=' + appToolbar;
   apparence += ', menubar=' + appMenubar;
   apparence += ', scrollbars=' + appScrollbars;
   apparence += ', resizable=' + appResizable;
   apparence += ', location=' + appLocation;
   apparence += ', directories=' + appDirectories;
   apparence += ', status=' + appStatus;

   // Ouverture de la fenetre
   window.open(url, titre, apparence);
   
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'ouvrirPopup650x600'
// Ouvre une popup ayant pour url 'url', de titre 'titre' et dont la taille
// de la popup sont 650px - 600px
//
// Parametres :
//    - url : url de la popup
//    - titre : titre de la popup
// Valeur retournee : booleen
//----------------------------------------------------------------------
function ouvrirPopup650x600(url, titre) {
   var parametres = new Array();
   parametres['height'] = 600;
   parametres['width'] = 650;
   parametres['scrollbars'] = 'yes';
   parametres['resizable'] = 'yes';
   return ouvrirPopup(url, titre, parametres);
}

//----------------------------------------------------------------------
// Traite la demande suivante 'ouvrirPopup800x650Scroll'
// Ouvre une popup ayant pour url 'url', de titre 'titre' et dont la taille
// de la popup sont 800px - 650px avec des scrollbars
//
// Parametres :
//    - url : url de la popup
//    - titre : titre de la popup
// Valeur retournee : booleen
//----------------------------------------------------------------------
function ouvrirPopup800x650Scroll(url, titre) {
   var parametres = new Array();
   parametres['height'] = 650;
   parametres['width'] = 800;
   parametres['top'] = 40;
   parametres['left'] = 20;
   parametres['scrollbars'] = 'yes';
   return ouvrirPopup(url, titre, parametres);
}

//----------------------------------------------------------------------
// Traite la demande suivante 'ouvrirPopup800x650'
// Ouvre une popup ayant pour url 'url', de titre 'titre' et dont la taille
// de la popup sont 800px - 650px
//
// Parametres :
//    - url : url de la popup
//    - titre : titre de la popup
// Valeur retournee : booleen
//----------------------------------------------------------------------
function ouvrirPopup800x650(url, titre) {
   var parametres = new Array();
   parametres['height'] = 715;
   parametres['width'] = 800;
   parametres['top'] = 40;
   parametres['left'] = 20;
   return ouvrirPopup(url, titre, parametres);
}

/**
* Test si au moins une checkbox commençant par un préfixe a été cochée
* @author 	Béatrice FREY
* @param  	idForm 			id du formulaire dans lequel sont les checkbox
* @param 	strChkTestNom	préfixe des checkbox à tester
* @param	strAlert		message d'erreur si aucune case selectionnée
* @param	strConfirm		message de confirmation à afficher (peut etre renseigné comme chaine vide si pas de confirmation)
*/
function isChecked(idForm, strChkTestNom, strAlert, strConfirm)
{
	nbcoche = 0;
	objForm = document.getElementById(idForm);
	
	// Nombre d'éléments du formulaire
	for(e=0;e<objForm.length;e++)
	{
		// Checkbox commençant par strChkTestNom	
		if(objForm.elements[e].name.indexOf(strChkTestNom)==0)	
		{
			var c = document.getElementById(objForm.elements[e].name);
			
			// On compte le nombre de checkbox cochées
			if(c.checked) nbcoche++;			
		}	
	}
	
	// Si aucune chechbox cochée -> message d'alerte, sinon demande de confirmation (si msg renseigné)
	if(nbcoche==0)
	{
		alert(strAlert);
		return false;
	}
	else
	{
		if(strConfirm != '') {
			return(confirm(strConfirm));
		}		
		else{
			return true;
		}
	}
}


/**
* Met à jour le champ hidden contenant une liste d'indentifiants d'enregistrements séparés par le séparateur passé en paramètre
* utilisé par exemple pour la suppression d'alertes d'un utilisateur particulier
* @author 	Béatrice FREY
* @param  	idChampHidden 		identifiant du champ hidden à mettre à jour
* @param 	idRecordCoche		identifiant de l'enregistrement coché/décoché
* @param	strSeparateur		séparateur utilisé pour délimirer les identifiants dans la chaine
*/
function majListeHidden(idChampHidden, idRecordCoche, strSeparateur){
	
	var nvInputHidden 	= '';
	var dejaCoche		= false;
	var inputHidden 	= document.getElementById(idChampHidden) ;	
	var tabId 			= inputHidden.value.split(strSeparateur); 
	
	// Reconstruction de la liste des ids
	for(e=0;e<tabId.length;e++) {
	
		// On remet les autres id des enregistrements deja cochés
		if(tabId[e] != idRecordCoche){			
			if(nvInputHidden == '') {
				nvInputHidden 	= tabId[e]; 		
			}else{
				nvInputHidden 	= nvInputHidden + '|' + tabId[e]; 		
			}
			
		}else{
			dejaCoche		= true;
		}
	}
	
	// Si absent il faut l'ajouter (cas coché)
	if(!dejaCoche){
		if(nvInputHidden == '') {
			nvInputHidden 	= idRecordCoche;	
		}else{
			nvInputHidden 	= nvInputHidden + '|' + idRecordCoche;		
		}
	}
		
	// On met la liste à jour dans le formulaire
	inputHidden.value	= nvInputHidden;
		
}//fin majListeHidden

//----------------------------------------------------------------------
// Traite la demande suivante 'videFormulaire'
// Vide tous les champs d'un formulaire (input, textarea)
//
// Parametres :
//    - element : identifiant du formulaire
//    - defaultTextarea : valeur par defaut des textarea ('' par defaut)
// Valeur retournee : booleen
//----------------------------------------------------------------------
function videFormulaire (element, defaultTextarea) {
   // Initialisation des variables
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (!defaultTextarea)
      defaultTextarea = '';
      
   for(var i = 0 ; i < element.childNodes.length ; i++) {
      if (element.childNodes[i].nodeName == '#text') {
         null;
      } else if (element.childNodes[i].nodeName == 'INPUT') {
         for(var j = 0 ; j < element.childNodes[i].attributes.length ; j++) {
            if (element.childNodes[i].attributes[j].nodeName == 'type'
                  && element.childNodes[i].attributes[j].nodeValue == 'text') {
               element.childNodes[i].value = '';
            }
         }
      } else if (element.childNodes[i].nodeName == 'TEXTAREA') {
         element.childNodes[i].innerHTML = defaultTextarea;
      } else {
         videFormulaire(element.childNodes[i], defaultTextarea);
      }
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'selectionneElementDecrit'
// Vide l'element 'element' si il est identique a 'valeurDescription'
//
// Parametres :
//    - element : element (ou identifiant de l'element)
//    - valeurDescription : valeur par defaut a vider
// Valeur retournee : booleen
//----------------------------------------------------------------------
function selectionneElementDecrit(element, valeurDescription) {
   // Initialisation des variables
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (!valeurDescription)
      valeurDescription = '';
   
   if (element.value && element.value == valeurDescription) {
      element.value = '';
   } else if (element.innerHTML && element.innerHTML == valeurDescription) {
      element.innerHTML = '';
   }
   
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'deselectionneElementDecrit'
// Remplit l'element 'element' si il est vide par 'valeurDescription'
//
// Parametres :
//    - element : element (ou identifiant de l'element)
//    - valeurDescription : valeur par defaut a ecrire
// Valeur retournee : booleen
//----------------------------------------------------------------------
function deselectionneElementDecrit(element, valeurDescription) {
   // Initialisation des variables
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (!valeurDescription)
      valeurDescription = '';

   if (element.value == '') {
      element.value = valeurDescription;
   }
   if (element.innerHTML == '') {
      element.innerHTML = valeurDescription;
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'toutSelectionner'
// Selectionne toutes les cases a cocher de noms 'nomElement'
//
// Parametres :
//    - nomElement : nom des cases a cocher
// Valeur retournee : booleen
//----------------------------------------------------------------------
function toutSelectionner(nomElement) {
   // Initialisation des variables
   listeElements = document.getElementsByName(nomElement);

   for (var i=0; i < listeElements.length ; i++) {
      listeElements[i].checked = 'checked';
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'rienSelectionner'
// Deselectionne toutes les cases a cocher de noms 'nomElement'
//
// Parametres :
//    - nomElement : nom des cases a cocher
// Valeur retournee : booleen
//----------------------------------------------------------------------
function rienSelectionner(nomElement) {
   // Initialisation des variables
   listeElements = document.getElementsByName(nomElement);

   for (var i=0; i < listeElements.length ; i++) {
      listeElements[i].checked = '';
   }
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'redirigerPageOpenner'
// Redirige la page ayant ouvert la fenetre vers 'url'
//
// Parametres :
//    - url : url de redirection
// Valeur retournee : booleen
//----------------------------------------------------------------------
function redirigerPageOpener(url) {
   opener.location = url;
   window.close();
   
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'majSelect'
// Met a jour l'element 'element' a 'liste2' si la valeur de l'element 'elementATester'
// est identique a 'test' sinon 'liste1' et reinitialise 'elementAReinitialiser' si besoin
//
// Parametres :
//    - element : element (ou identifiant de l'element)
//    - liste1 : liste par defaut des options
//    - liste2 : liste des options mise a jour
//    - elementATester : element (ou identifiant de l'element) a tester
//    - test : valeur de l'element a tester
//    - elementAReinitialiser : element (ou identifiant de l'element) a reinitialiser
// Valeur retournee : booleen
//----------------------------------------------------------------------
function majSelect(element, liste1, liste2, elementATester, test, elementAReinitialiser) {
   // Initialisation des variables
   var compteur = 0;
   var listeMAJ = false;
   var tailleListe1 = 0;
   var tailleListe2 = 0;
   if (document.getElementById(element))
      element = document.getElementById(element);
   if (document.getElementById(elementATester))
      elementATester = document.getElementById(elementATester);
   if (document.getElementById(elementAReinitialiser))
      elementAReinitialiser = document.getElementById(elementAReinitialiser);
      

   // Compte le nombre d'options de chaque liste
   for (var i in liste1) {
      tailleListe1++;
   }
   for (var i in liste2) {
      tailleListe2++;
   }

   if (elementATester.value == test && element.options.length != tailleListe2) {
      // Utilisation de liste2
      listeMAJ = liste2;
   } else if (element.options.length != tailleListe1) {
      // Utilisation de liste1
      listeMAJ = liste1;
   }
   
   if (listeMAJ) {
      // Efface toutes les options
      for (var i in element.options) {
         element.options[i] = null;
      }
   
      // Mise en place de la nouvelle liste d'options
      for (var i in listeMAJ) {
         var option = document.createElement("option");
         option.value = i;
         option.text = listeMAJ[i];
         element[compteur] = option;
         compteur++;
      }
      // Remise a zero de l'option selectionnees
      element.selectedIndex = 0;
      elementAReinitialiser.selectedIndex = 0;
   }
      
   return true;
}

//----------------------------------------------------------------------
// Traite la demande suivante 'resizeImage'
// Redimentionne les dimensions d'une image à partir de la largeur max 'largeurMax'
// et de sa hauteur max 'hauteurMax'
//
// Parametres :
//    - image : l'image (ou identifiant de l'image ou url de l'image)
//    - largeurMax : largeur maximum de l'image
//    - hauteurMax : hauteur maximum de l'image
// Valeur retournee : booleen
//----------------------------------------------------------------------
function resizeImage(image, largeurMax, hauteurMax) {
   // Initialisation des variables
   var rapportLargeur = 0;
   var rapportHauteur = 0;

   if (document.getElementById(image))
      image = document.getElementById(image);
   
   // Calcul du rapport
   rapportLargeur = image.width / largeurMax;
   rapportHauteur = image.height / hauteurMax;

   if (rapportLargeur >= rapportHauteur) {
      image.style.width = largeurMax + 'px';
      //image.style.height = (image.height / rapportLargeur) + 'px';
   } else {
      //image.style.width = (image.width / rapportHauteur) + 'px';
      image.style.height = hauteurMax + 'px';
   }
}


//----------------------------------------------------------------------
// Redimentionne les dimensions d'une image ? partir de la largeur max 'inMW'
// et de sa hauteur max 'inMH'
//
// Petite diff?rence par rapport ? 'resizeImage' :
// - l'image doit s'afficher dans un p?rim?tre de inMW x inMH
// - si largeur > inMW, on r?duit proportionnellement l'image pour que la largeur = inMW
// - si hauteur > inMH, on r?duit proportionnellement l'image pour que la hauteur = inMH
// - on n'?largit jamais l'image ; si les 2 dimensions sont plus petites que les dimensions max,
//   elle reste ? sa taille d'origine
//----------------------------------------------------------------------
function redimImage(oImg, inMW, inMH)
{
  // Cette function recoit 3 parametres
  // oImg : Objet image
  // inMW  : Largeur maximale
  // inMH   : Hauteur maximale
  var maxWidth = inMW;
  var maxHeight = inMH;
  // Declarations des variables "Nouvelle Taille"
  var dW = 0;
  var dH = 0;

  // On recupere les tailles reelles
  var h = dH = oImg.height;
  var w = dW = oImg.width;
  // Si la largeur ou la hauteur depasse la taille maximale
  if ((h >= maxHeight) || (w >= maxWidth)) {
    // Si la largeur et la hauteur depasse la taille maximale
    if ((h >= maxHeight) && (w >= maxWidth)) {
      // On cherche la plus grande valeur
      if (h > w) {
        dH = maxHeight;
        // On recalcule la taille proportionnellement
        dW = parseInt((w * dH) / h, 10);
      } else {
        dW = maxWidth;
        // On recalcule la taille proportionnellement
        dH = parseInt((h * dW) / w, 10);
      }
    } else if ((h > maxHeight) && (w < maxWidth)) {
      // Si la hauteur depasse la taille maximale
      dH = maxHeight;
        // On recalcule la taille proportionnellement
      dW = parseInt((w * dH) / h, 10);
    } else if ((h < maxHeight) && (w > maxWidth)) {
      // Si la largeur depasse la taille maximale
      dW = maxWidth;
        // On recalcule la taille proportionnellement
      dH = parseInt((h * dW) / w, 10);
    }
  }
  
  oImg.width = dW;
  oImg.height = dH;
  
};