//-------------------- function PrmURL() -----------------------------------
/*
  Fonction qui renvoi dans un tableau la liste des parametre dans l'url
  Le tableau est indexé sur le nom des parametre et contiens leur valeur
  exemple : http://mapage.php?toto=present&titi=absent
  
   tPrmURL[toto]=present
   tPrmURL[titi]=absent

*/
//------------------------------------------------------------------------------
function PrmURL()
{

var prmURL	=	window.location.search;
var tPrmURL = new Array();

if(prmURL!='')
{
	//Transforme tous les signes de la chaîne à transmettre en caractères ASCII normaux
  prmURL	=	unescape(prmURL);

  //enleve le ?
  prmURL=prmURL.substr(1);

  //recupere chaque valeur entre &
  prmURL=prmURL.split('&');

  var iParams;
  var tPrmInter = new Array();
  var prmName;
  var prmValue;

  for(iParams=0;iParams < prmURL.length; iParams++)
  {
    //sépare la variable et sa valeur
    tPrmInter	=  prmURL[iParams].split('=');
    prmName		=  tPrmInter[0];
    prmValue	=  tPrmInter[1];

    // stocke dans le tableau sous l'index du nom de variable
    tPrmURL[prmName]=prmValue;

    //alert(tPrmURL[prmName]+'__'+prmName+'__'+prmValue);
  }

}
//alert(window.location.search);

return(tPrmURL);
}

//================================================================= FIN FONCTION

//-------------------- function is_numeric() -----------------------------------
/*
  Fonction is_numeric équivalente à celle en php
  renvoie vrai si l'argument value est un nombre
  remarque: Aussi bien les nombres entiers que les nombres avec décimales sont
	reconnus comme nombres valides. Pour les nombres avec décimales, le symbole
	décimal doit être un point.

*/
//------------------------------------------------------------------------------
function is_numeric(value)
{
 if(isNaN(value) == true)
 {
  //alert(value + " n'est pas un nombre!");
  return(false);
 }
 else return(true);
}
//================================================================= FIN FONCTION


//-------------------- function in_array() -------------------------------------
/*
  Fonction in_array équivalente à celle en php
  renvoie vrai si l'argument valeurRecherchee est trouver dans le tableau arraySRC
  remarque: ne fonctionne pour le moment qu'avec des tableau unidimensionnelle
*/
//------------------------------------------------------------------------------

function in_array(arraySRC , valeurRecherchee)
{

var icells		=		0;

//parcours du tableau source
while(arraySRC[icells])
{
	//test si valeur trouvée
  if(arraySRC[icells] == valeurRecherchee)
  {
    return(true);
  }
  icells++;
}

return(false);

}
//================================================================= FIN FONCTION


/*---------------- function generateAndFilterSelect(optCode)------------------
/*
	p.lacour 13.04.07 création

  Cette fonction rempli un select avec création des optgroup et le filtre en meme temps:
	- elle pioche dans un select (idSource) une liste d'option
	- elle recupere une liste (lstOpt) de code d'option qui existe dans
	  idSource
	- si iIsLstAutorisedOrForbidden =  1, elle ajoute dans le select (idDest)  les
		options à partir de idSource qui font  partie de la lstOpt
	  si iIsLstAutorisedOrForbidden =  0, elle ajoute dans le select (idDest)  les
		options à partir de idSource qui	ne font  partie de la lstOpt


  entrée : idSource: ID du select source
           idDest  : ID du select dest
           lstOpt: liste des code options qui existe dans le select source
           et qui doivent apparaitre dans le select dest
           iIsLstAutorisedOrForbidden: indique si la liste fourni est une liste
           de code option autorisé ou interdite
					 0 = interdite
					 1 = autorisé
*/
//------------------------------------------------------------------------------

function generateAndFilterSelect(idSource,idDest,lstOpt,iIsLstAutorisedOrForbidden)
{
  // select source dans lequel on va piocher les options
  var selectOptFromHidden 	=  document.getElementById(idSource);

  //select destinataire dans lequel on va rajouter les options
  var selectDest          	=  document.getElementById(idDest);

  // on met dans un tableau la liste des options
  // qui doivent/doivent pas apparaitre dans la liste dest
  var tOptions = lstOpt.split(",");

	//on vide le select dest avant de le remplir
  while(selectDest.length > 0) selectDest.options[0] = null;

  //on vide les optgroup du selectDest
	var optgroupDest =  selectDest.childNodes;
	while(optgroupDest.length > 0) selectDest.removeChild(optgroupDest[0]);


	//------------- Creation des optgroup et des options -------------------------

	var nbOpt = 0; //nombre d'option du select dest

	//liste des noeuf enfant du select source
  var optgroups 		 = selectOptFromHidden.childNodes;

  //contient le nombre d'option pour chaque optgroup
	var tNbOptInOptGrp = new Array();

	//parcours la liste des noeuf enfants du select
	for(var ioptgrp = 0 ; ioptgrp < optgroups.length ; ioptgrp++)
	{
		//on tombe sur un optgroup
		if(optgroups[ioptgrp].nodeName == 'OPTGROUP')
		{
		  //alert(optgroups[ioptgrp].label);

		  //raz nombre d'option dans le group
		   tNbOptInOptGrp[ioptgrp]  = 0;

			//liste des noeud enfants de l'opt group
			var options = optgroups[ioptgrp].childNodes;

			//parcours cette liste
			for(var iopt = 0 ; iopt < options.length ; iopt++)
			{
				//verifie qu'il s'agit d'une option
				if(options[iopt].nodeName == 'OPTION')
				{
					//alert(options[iopt].text);

					//drap qui indique si on doit ajouter l'option
          var addOpt = 0;

          //soit on verifie que l'option n'appartient pas à la liste fourni
					if(iIsLstAutorisedOrForbidden == 0)
					{
					  if(!in_array(tOptions,options[iopt].value)) addOpt = 1;
					}
					else //soit on verifie que l'option appartient à la liste fourni
					{
					   if(in_array(tOptions,options[iopt].value)) addOpt = 1;
					}

					//on regarde si l'option doit apparaitre
			    //if(in_array(tOptions,options[iopt].value))
			    if(addOpt==1)
				  {
				      //creation de l'opt group
				      //on ne créer le group que s'il existe au moins une option selectionné
				      // et si aucune option n'a pas déja été crée
							if(tNbOptInOptGrp[ioptgrp] == 0)
							{
							  var optgroup 		= document.createElement('optgroup');
								optgroup.label 	= optgroups[ioptgrp].label;
								selectDest.appendChild(optgroup);
							}

				      //creation de l'option
				    	var opt 									= 		new Option(options[iopt].text,options[iopt].value);
			 			 	selectDest.options[nbOpt] = 		opt;//mise a jour

							nbOpt++; //maj nb d'option dans le select
							tNbOptInOptGrp[ioptgrp]++; //maj nb d'option pour le group

					}
 			  }
			}
		}
	}
 //---------------------------------------------------------------- fin création

	return(true);
}
//================================================================= FIN FONCTION


//------------ insertAdjacentHTML()---------------------------------------------
// cette fonction à pour but d'emuler la méthode insertAdjacentHTML propriétaire
// a Microsoft
// Le probleme est que la méthdode de base ne fonctionne pas sous FireFOx
// celle ci oui
// parametre:
//   elementID : ID de l'element dans lequel il faut inserer le code HTML
//   sText      : contenu  à insérer
//   sWhere  : mention exacte où le texte HTML doit être inséré.
//						beforeBegin: si le texte doit être inséré avant le repère d'ouverture HTML,
//						afterBegin: si le texte doit être inséré après le repère d'ouverture
//						et avant le contenu,
//						beforeEnd: si le texte doit être inséré à la fin du contenu avant le repère de fermeture, ou
//						afterEnd: si le texte doit être inséré après le repère de fermeture.

var g_isIE = -1;
var currentSelection = 0;

///////////////// Utility functions

function insertAdjacentHTML(sWhere, sText, elementID)
{

	var element = document.getElementById(elementID);

	if (isIE() == 1)
	{
		element.insertAdjacentHTML(sWhere, sText);
	}
	else
	{
		// Firefox...
		var r = document.createRange();
		r.setStartBefore(element);

		var parsedNode 	= r.createContextualFragment(sText);
		var parent 			= element.parentNode;

	  switch(sWhere)
		{
			case 'beforeBegin':
				element.parentNode.insertBefore(parsedNode,element)
				break;

			case 'afterBegin':
				element.insertBefore(parsedNode,element.firstChild);
				break;

			case 'beforeEnd':
				element.appendChild(parsedNode);
				break;

			case 'afterEnd':
				if (element.nextSibling)
					element.parentNode.insertBefore(parsedNode,element.nextSibling);
				else
					element.parentNode.appendChild(parsedNode);

				break;
		}

	}
}
//================================================================= FIN FONCTION

//----------FUNCTION isIE()-----------------------------------------------------
// Fonction qui permet de tester si ne navigateur est compatible avec la méthode
// insertAdjacentHTML
// normalement, seul IE l'est, d'ou le nom de la fonction

function isIE()
{
	if (g_isIE != -1)
	{
		return g_isIE;
	}
	else //uninitialized
	{
		var element = document.body;
		try
		{
			// IE
			element.insertAdjacentHTML("beforeEnd", "&nbsp");
			g_isIE = 1;
		}
		catch(e)
		{
			g_isIE = 0;
		}
	}

	return g_isIE;
}

//================================================================= FIN FONCTION


//--------------  function cocheBoxe()------------------------------------------
/*
 Script associé à la fonction PHP checkboxDesign()
 Cette fonction simule un checkbox de maniere plus joli
 Elle permute des images coché <-> pas coché (ou inversement)
 et change la valeur d'un input hidden pour simuler un input de type checkbox

 prend en parametre
 - l'id de l'image
 - l'id du input hidden à changer,
 - le chemin de l'image a associé a la valeur 1 de l'input (image coché par exemple)
 - le chemin de l'image a associé à la valeur 0 de l'input hidden( image pas coché par exemple)
 - un entier qui permet de forcer une action coche/decoche : 0 pour decoche, 1 pour cocher
*/

//------------------------------------------------------------------------------
function cocheBoxe(idImgCheckboxDesign, idInputHidden,pathImgOUI,pathImgNON, iActionForced)
{
	//alert(idImgCheckboxDesign+'--'+idInputHidden+'--'+pathImgOUI+'--'+pathImgNON+'--'+iActionForced);
	
	// objet de l'image à manipuler
	var objImg =  document.getElementById(idImgCheckboxDesign);

	//input hidden qui stocke la valeur coché/pas coché
	var objInputHidden 	=		 document.getElementById(idInputHidden);

	if(!objImg || !objInputHidden)
	{
		alert("Erreur lors de la récupération d'un objet");
		return(false);
	}

	var etat  	= 	 objInputHidden.value;

	//coché, on decoche ou bien on à forcé le décochage
	if( (etat == 1 || etat === true || iActionForced == 0) && iActionForced != 1)
	{
	  objImg.src							=			pathImgNON;
	  objInputHidden.value 		= 		0;

	}
	else // pas coché, on coche
	{
	  objImg.src							=			pathImgOUI;
	  objInputHidden.value 		= 		1;

	}

return(true);
}
//===================================================== FIN  FUNCTION cocheBoxe


//------- FUNCTION load_iFrame (sPageName,sIframeID)------------------------------

// Cette fonction modifie la source d'un iframe
// Prend  en paramètre
// sUrl : la page à charger dans l'iframe (chemin fichier) avec ses params
// sIframeID : ID de l'iframe dont il faut modifier la source

function load_iFrame(sUrl,sIframeID)
{
  //alert(sPageName+'----'+sIframeID);
  var iframe = document.getElementById(sIframeID);
  
  if(iframe)
    iframe.src = sUrl;
  else
    alert('Error while connecting to object');
  
	return;
}

//===================================================== FIN  FUNCTION load_iFrame



//------- FUNCTION showHiddeObject(iAction,sObjectID) --------------------------

// Cette fonction modifie la classe d'un objet
// pour soit le faire apparaitre soit le cacher
// pour que cela fonctionne il faut absolument respecter la règle suivante
//
// Il doit tjs existé au moins 2 classes (une pour chaque visiblité) et chaque
// classe doit respecter la même syntaxe, à savoir: même racine + Visbile ou
// Hidden à la fin
//
// ex: .divWizardVisible et .divWizardHidden   OU .divWizardVISIBLE et .divWizardHIDDEN
//
//  sObjectID: id de l'objet à cacher/montrer
//  iAction: entier permettant de définir des actions

function showHiddeObject(iAction,sObjectID)
{

	var object =	document.getElementById(sObjectID);

	if(object)
	{

		if(iAction == 1)
		{
			object.className = object.className.replace('Hidden','Visible');//'iframeWizardVisible';
			object.className = object.className.replace('HIDDEN','VISIBLE');
		}
		else
		{
			object.className = object.className.replace('Visible','Hidden'); //'iframeWizardHidden';
			object.className = object.className.replace('VISIBLE','HIDDEN');
		}
	}
	else
  {
    alert('error while connecting to object');
    //alert(iAction+'---'+sObjectID);
  }

	return;
}

//================================================ FIN  FUNCTION showHiddeObject


//------- FUNCTION enableObject-------------------------------------------------
// cette fonction modifie le status DISABLED d'un object
// prend en paramètre l'ID de l'object et la nouvelle valeur du paramètre
// DISABLED

function enableObject(sOjectID,bStatus)
{
  var object 			=		 document.getElementById(sOjectID);
  object.disabled =    bStatus;
  return;
}
//=================================================== FIN  FUNCTION enableObject




//------- FUNCTION changeOjectValue---------------------------------------------
// cette fonction change la valeur d'un object
// prend en paramètre l'ID de l'object et la nouvelle valeur
// utile lors d'appel depuis des page parente

function changeOjectValue(sObjectID,sValue)
{
  //alert(sObjectID+'---'+document.getElementById(sObjectID).value);
  document.getElementById(sObjectID).value = sValue;
  //alert(sObjectID+'---'+document.getElementById(sObjectID).value);
  return;
}
//=============================================== FIN  FUNCTION changeOjectValue





//------- FUNCTION razObjectInForm----------------------------------------------
// cette fonction raz la valeur de tous les object d'un formulaire
// par exemple decoche une  serie de checkbox, met à vide une liste d'input texte..
// prend en paramètre 
// - sFormName : le nom du formulaire dans lequel se  trouve les objets
// - sObjectType : le type d'objet qu'il faut razer
// - si sObjectType est omis alors la fonction raz tous les types d'objects
// - iAction: drapeau servant parfois à conditionner des traitements

//var tTypeForbiddenToRaz = new Array("button","submit");


function razAllObjectsInForm(sFormName,sObjectType,iAction)
{

  for(i	=	0 ; i	<	document.forms[sFormName].elements.length ; i++)
	{
		if(document.forms[sFormName].elements[i].type == sObjectType || !sObjectType)
		{
      switch(sObjectType)
      {
        case "checkbox"://alert(sObjectType);
                        
                        switch(iAction)
                        {
                          case 0: //décoche
                                  document.forms[sFormName].elements[i].checked = false;
                                  
                                  break;
                                  
                          case 1: //coche
                                  document.forms[sFormName].elements[i].checked = true;
                                 
                                  break;
                                  
                          default: //prend la valeur inverse de sa valeur actuel
                                 document.forms[sFormName].elements[i].checked = !document.forms[sFormName].elements[i].checked;
                                 break;
                        }
                      
        default:
                document.forms[sFormName].elements[i].value = '';
                break;
      }
      
		}
	}

	return;
}

//============================================= FIN FUNCTION razAllObjectsInForm


//--------- Detection souris au dessus d'un element ----------------------------
// ok sous IE,FF ET SAFARI
/*
// --- get some monitor function ---//
var m=monitorMouseMoveForElement(
   document.getElementById("foo")
);


// --- lib ---//
function monitorMouseMoveForElement(elem) {
   var isMouseOver = false;


   _e(elem, "onmouseover",function (evt) { isMouseOver=true; });
   _e(elem, "onmouseout",
     function (evt) {
       isMouseOver = contains(
         this, (evt=evt||window.event, evt.relatedTarget||evt.toElement)
       );
     }
   );


   function contains(cer, cee){
     if(cer.contains) {
       return cer.contains(cee);
     } else if(typeof cee.parentNode!= "undefined") {
       return (function(cr, ce){
         return cr==ce ||
                ce&&ce.parentNode&&arguments.callee(cr,ce.parentNode)||
                false ;
       })(cer, cee);
     } else {
       return false;
     }
   }


   function _e(obj, evt, func) {
     if(obj[evt]) {
       obj[evt] = (function(x){
         return function (evt) {
           func.call(this, evt);
           return x.call(this, evt);
         }
       })(obj[evt]);
     } else {
       obj[evt] = func ;
     }
   }


   return function() {
     return isMouseOver;
   };


}
*/
//----------------------------------- FIN LIB DETECTION SOURIS AU DESSUS ELEMENT