//--- SÉPARATEURS pour les SÉLECTIONS MULTIPLES --------------
var NRIS_SEPARATOR = ",";
var DESCS_SEPARATOR = "~*!*~";

//--- Capturer la POSITION du CURSEUR (pour les tooltip) -----
document.onmousemove = getCursorPosition;

//=============================================================================================		
//=== CONSERVE la POSITION du CURSEUR dans des variables publiques ============================
//=== (pour openToolTip(...))                                      ============================
//=============================================================================================		
var mouseX = 0;
var mouseY = 0;
//=============================================================================================		
//=== Enregistre la position actuelle du curseur dans les variable globale mouseX et mouseY ===
//=============================================================================================
function getCursorPosition(e)
{
	// ----- Internet Explorer -----
	if (document.all)
	{
		mouseX = event.screenX;
		mouseY = event.screenY;
	}
	// ----- Autres navigateurs ----
	else
	{
		mouseX = e.screenX;
		mouseY = e.screenY;
	}
}

//=============================================================================================		
//=== Affiche un TOOLTIP HTML =================================================================
//=============================================================================================		
function openToolTip(sUrl, sName, iWidth, iHeight, bScrollBars, iXPosAdj, iYPosAdj)
{
	var xPos = mouseX;
	var yPos = mouseY;
	
	// ----- POSITIONNER TOOLTIP à DROITE DU CURSEUR ----------------------
	xPos = xPos + 15;

	// ----- POSITIONNER TOOLTIP en HAUT DU CURSEUR -----------------------
	yPos = yPos - iHeight;

	// ----- S'ASSURER que le tooltip RESTE DANS L'ÉCRAN ------------------
	if ((xPos+iWidth) >= screen.availWidth)
		xPos = xPos - iWidth - 30;
	if (yPos <= 0)
		yPos = 0;
		
	// ----- AJUSTER la POSITION SI DEMANDÉ -------------------------------
	if (iXPosAdj != null)
		xPos += iXPosAdj;
	if (iYPosAdj != null)
		yPos += iYPosAdj;
	
	// ----- AFFICHER les BARRES de DÉFILEMENT? ---------------------------
	var scrollBars = "yes"; // Oui par défaut
	if (bScrollBars != null && bScrollBars==false)
		scrollBars = "no";
	
	// ----- OUVRIR le POPUP ----------------------------------------------
	var toolTip = window.open(sUrl, sName,
														"width="+iWidth+
														",height="+iHeight+
														",screenX="+xPos+ 
														",screenY="+yPos+
														",left="+xPos+ 
														",top="+yPos+
														",scrollbars="+scrollBars+
														",resizable=yes",
														true);

	// ----- PLACER le FOCUS sur le TOOLTIP -------------------------------
	if (toolTip != null)
		toolTip.focus();
	
	return toolTip;
}

//=============================================================================================
//===== Cette fonction permet de retirer tous les caractères spéciaux d'une chaîne  ===========
//===== de caractères																																===========
//=============================================================================================
function replace(string, text, by)
{
	var strLength=string.length;
	var txtLength=text.length; 
    if ((strLength == 0) || (txtLength == 0)) 
		return string; 

    var i = string.indexOf(text); 
    if ((!i) && (text != string.substring(0,txtLength))) 
		return string; 
    if (i == -1) 
		return string; 

    var newstr = string.substring(0,i) + by; 
	
    if (i+txtLength < strLength) 
        newstr += replace(string.substring(i+txtLength,strLength),text,by); 
	
    return newstr; 
}
			
//=============================================================================================
//===== Cette fonction permet de retirer tous les caractères spéciaux d'une chaîne  ===========
//===== de caractères																																===========
//=============================================================================================
function removeSpecialCharacters(str)
{
	var allowedCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
	var returnedString = "";
	
	for (var i=0; i<str.length; i++)
	{
		if (allowedCharacters.indexOf(str.charAt(i).toUpperCase()) != -1)
			returnedString += str.charAt(i);
	}	

	return returnedString;
}

//=============================================================================================		
//=== Trouve la frame spécifiée dans en remontant la
//=== hierachie des fenêtres ouvertes
//=============================================================================================		
function getFrame(frameName)
{
	if (frameName=="")
		return false
		
	//--- fenêtre courante ------------------------
	if (eval("window.top."+frameName))
		return eval("window.top."+frameName);
	//--- fenêtre parent --------------------------
	else if (window.top.opener && eval("window.top.opener.top."+frameName))
		return eval("window.top.opener.top."+frameName);
	//--- fenêtre grand-parent --------------------
	else if (window.top.opener && window.top.opener.top.opener && eval("window.top.opener.top.opener.top."+frameName))
		return eval("window.top.opener.top.opener.top."+frameName);
	//--- Pas trouvé -------------------------------
	else
	   return false;
}

//=============================================================================================		
//=== Ouvre le Quick Tour centré, resizable et sans toolbars  =================================
//=== Retourne l'objet Window =================================================================
//=============================================================================================		
function openQuickTourEservice(qtLang, moduleId, stepId)
{
	if (moduleId == null)
		moduleId = "";
	if (stepId == null)
		stepId = "";

	//---- Quick Tour en anglais et français seulement ----------------------------
	if (qtLang != 1 && qtLang != 2)
		qtLang = 2;

	return openWindowCustom("/servlet/SSXMLParser?xsl_url=/quick_tour/quick_tour.xsl&xml_url=/quick_tour/quick_tour_eservice.xml&language="+qtLang+"&module_id="+moduleId+"&step_id="+stepId, "QuickTour", -80, -80, true, false, "yes");
}

//=============================================================================================		
//=== Ouvre un popup centré, resizable et sans toolbars  ======================================
//=== Retourne l'objet Window =================================================================
//=============================================================================================		
function openWindow(sUrl, sName, iWidth, iHeight, bScrollBars)
{
	return openWindowCustom(sUrl, sName, iWidth, iHeight, bScrollBars, false, "yes", false);
}

//=============================================================================================		
//=== Ouvre un popup centré, resizable, sans toolbars avec barre de statut  ===================
//=== Retourne l'objet Window =================================================================
//=============================================================================================		
function openWindowStatus(sUrl, sName, iWidth, iHeight, bScrollBars)
{
	return openWindowCustom(sUrl, sName, iWidth, iHeight, bScrollBars, false, "yes", true);
}

//=============================================================================================		
//=== Ouvre un popup centré, resizable AVEC toolbars et url ===================================
//=== Retourne l'objet Window =================================================================
//=============================================================================================		
function openWindowToolbar(sUrl, sName, iWidth, iHeight, bScrollBars)
{
	return openWindowCustom(sUrl, sName, iWidth, iHeight, bScrollBars, true, "yes", false);
}

//=============================================================================================		
//=== Ouvre un popup centré, resizable AVEC toolbars et url ===================================
//=== Retourne l'objet Window =================================================================
//=============================================================================================		
function openWindowCustom(sUrl, sName, iWidth, iHeight, bScrollBars, bToolBar, sResizable, bStatusBar)
{
   var WINDOW_TASKBAR_HEIGHT = 40;
 	//-- Si largeur négative c'est que l'on veut prendre tout l'écran sauf cette largeur ------
   if (iWidth<1)
	   iWidth = screen.availWidth + iWidth;
	   
 	//-- Si hauteur négative c'est que l'on veut prendre tout l'écran sauf cette hauteur ------
   if (iHeight<1)
	   iHeight = screen.availHeight + iHeight;
   
   var y = (screen.availHeight - iHeight)/2;
   y = y - WINDOW_TASKBAR_HEIGHT
   if (y<1)
	   y=1;
   var x = (screen.availWidth - iWidth)/2;
   
   var sScrollBars="no";
   if (bScrollBars)
   		sScrollBars="yes";   

   var sStatusBar="0";
   if (bStatusBar)
   		sStatusBar="1";
		
   var sToolBar="";
   if (bToolBar)
	   sToolBar=",toolbar,location";

   var popUp = window.open(sUrl, 
   						   sName,
						  "width="+iWidth+
						  ",height="+iHeight+
						  ",screenX="+x+ 
						  ",screenY="+y+
						  ",left="+x+ 
						  ",top="+y+
						  ",scrollbars="+sScrollBars+
						  ",resizable="+sResizable+
						  ",status="+sStatusBar+
						  sToolBar,
						  true);
	
	if (popUp!=null)
		popUp.focus();
	return popUp;
}

//================================================================================================
//===== RETOURNE en string le CHEMIN DU OPENER d'une FENÊTRE SPÉCIFIÉE (false si existe pas) =====
//================================================================================================		
function getOpenerPath(sPointer)
{
	// Extraire le nom du serveur
	var sHostString = top.location.host;

	// Ajouter . manquant
	if (sPointer != "")
		sPointer += ".";
	
	try
	{
		if (eval(sPointer+"top.opener") && 
				(eval("typeof("+sPointer+"top.opener.location.host)")=='string') && 
				(eval(sPointer+"top.opener.location.host")==sHostString))
		{
			sPointer += "top.opener";
			return sPointer;
		}
		else
			return false;
	}
	catch (e)
	{
		return false;
	}
}

//=======================================================================================
//===== Cette fonction sevira à remonter jusqu'au 'top' original dans une série de  =====
//===== fenêtres ouvertes, par contre, la boucle devra s'arrêter à la première      =====
//===== instance qui contient le même site web que l'instance de départ.            =====
//=======================================================================================
function getOriginalTop()
{
	var sHostString = top.location.host;
	var sOpenerHostString;
	var sPointer = "";
	var bLoopContinued = true;	

	try
	{
		while (bLoopContinued)
		{
			if (eval(sPointer+"top.opener") && 
			    (eval("typeof("+sPointer+"top.opener.location.host)")=='string') && 
				(eval(sPointer+"top.opener.location.host")==sHostString))
				sPointer = sPointer + "top.opener.";
			else
				bLoopContinued = false;
		}
	}
	catch (e)
	{
	}
	finally
	{
		return eval(sPointer+"top");
	}
}
//=============================================================================================
//===== RECHERCHE un ELEMENT par son ID dans TOUTES LES FRAMES du TOP EN COURS ================
//=============================================================================================		
function getElementByIdSubFrames(sElementId, oWindow)
{
    if (!oWindow)
		oWindow=window;
	var oElement = oWindow.document.getElementById(sElementId);;
	//--- Boucler sur les sous-frames -----------------------------------
	for (var i=0; i<oWindow.frames.length && !oElement; i++)
		oElement = getElementByIdSubFrames(sElementId, oWindow.frames[i]);
				
	return oElement;
}

//=======================================================================================
//===== Remonte les fenêtres parent en cherchant leur arborecsence de frames à      =====
//===== la recherche d'un objet.                                                    =====
//=======================================================================================
function getElementByIdInOpenedWindows(sElementId, oWindow)
{
	var oElement = null;
    if (!oWindow)
		oWindow=window;
	try
	{
	    oElement = getElementByIdSubFrames(sElementId, oWindow.top);	
		//--- Appel récursif sur Opener ------------------------
		if (oElement==null && oWindow.top.opener)
			oElement = getElementByIdInOpenedWindows(sElementId, oWindow.top.opener.top)
	}
	catch (e)
	{
	}
	finally
	{
		return oElement;
	}
}

//=============================================================================================
//===== RECHERCHE un ELEMENT par son ID dans TOUTES LES FRAMES du TOP ORIGINAL ================
//=============================================================================================		
function getElementByIdInOriginalTop(elementId)
{
	var originalTop = getOriginalTop();
	var element = null;
	
	for (var i = 0; i < originalTop.frames.length; i++)
	{
		element = originalTop.frames[i].document.getElementById(elementId);
		if (element)
			return element;
	}
	return null;
}

//=============================================================================================
//===== AFFICHE l'IMAGE indiquant à l'usager qu'une OPÉRATION est EN COURS ====================
//=============================================================================================		
function startLoading(appLanguage, bSetDataSaved)
{    
	// ----- LEXIQUE --------------------------------------------------------------------------
	var langIndex = appLanguage - 1;
	if (langIndex!='0' && langIndex!='1' && langIndex!='2' && langIndex!='4')
		langIndex='1'; // Anglais par défaut
	var TXT_WARNING_CURRENTLY_PROCESSING = ["Une autre opération est présentement en cours de traitement. Souhaitez-vous l'annuler et continuer?",
											"Another operation is currently in process. Do you wish to cancel it and continue?",
											"Another operation is currently in process. Do you wish to cancel it and continue?",
											"",
											"En este momento hay otra operación en proceso. ¿Desea cancelarla y contuinuar?"]; 
	var TXT_WARNING_LOOSE_CHANGES = ["Valeurs modifiées. Continuer et perdre les changements?",
									 "Modified values. Continue and lose changes?",
									 "Modified values. Continue and lose changes?",
									 "",
									 "Valores modificados. ¿Desea continuar y perder los cambios?"];
	// ----------------------------------------------------------------------------------------
	var oOriginalTop = eval(getOriginalTop());
						
	if (bSetDataSaved)
	{
		// ----- Modifications NON-SAUVÉES ----------------
		if (oOriginalTop.document.isDataModified && 
			!window.confirm(TXT_WARNING_LOOSE_CHANGES[langIndex]))
			return false;
	
		// ----- Changer flag de DATA MODIFIED ------------
		setDataSaved();
	}
															 
	// ----- Une OPÉRATION est DÉJÀ EN COURS ------------
	if (oOriginalTop.document.isAppLoading && 
	    !window.confirm(TXT_WARNING_CURRENTLY_PROCESSING[langIndex]))
		return false;
	
	// ----- AFFICHER l'image PROCESSING ----------------
	var appProcessing = getElementByIdInOpenedWindows('appProcessing', window);
	if (appProcessing)
		appProcessing.style.visibility = 'visible';

	// ----- CHANGER le CURSEUR pour un SABLIER ---------
	changeCursorInOpenedWindows('wait');

	// ----- Changer flag de LOADING --------------------
	oOriginalTop.document.isAppLoading = true;

	return true;
}

//=============================================================================================
//===== CACHE l'IMAGE indiquant à l'usager qu'une OPÉRATION est EN COURS ======================
//=============================================================================================		
function stopLoading(bSetDataSaved)
{
	var oOriginalTop = eval(getOriginalTop());

	// ----- CACHER l'image PROCESSING -------------------------
	var appProcessing = getElementByIdInOpenedWindows('appProcessing', window);
	if (appProcessing)
		appProcessing.style.visibility = 'hidden';

	// ----- RÉINITIALISER le CURSEUR ---------------------------	
	changeCursorInOpenedWindows('auto');

	// ----- Changer flag de LOADING ----------------------------
	oOriginalTop.document.isAppLoading = false;

	// ----- Changer flag de DATA MODIFIED ----------------------
	if (bSetDataSaved)
		setDataSaved();
}

//=============================================================================================
//===== Setter flag pour dire que de l'information a été modifiée et n'est pas sauvegarder ====
//=============================================================================================		
function setDataModified()
{			 
	var oOriginalTop = eval(getOriginalTop());
	oOriginalTop.document.isDataModified = true;
}

//=============================================================================================
//===== Setter flag pour dire qu'aucune information n'a été modifiée ==========================
//=============================================================================================		
function setDataSaved()
{			
	var oOriginalTop = eval(getOriginalTop());
	oOriginalTop.document.isDataModified = false;
}

//=============================================================================================
//===== L'information a été modifiée et n'est pas sauvegarder? ================================
//=============================================================================================		
function isDataModified()
{			 
	var oOriginalTop = eval(getOriginalTop());
	return (oOriginalTop.document.isDataModified == true);
}

//=============================================================================================
//===== Enlève les espaces de gauche d'une string =============================================
//=============================================================================================		
function trim_left(in_string)
{
	var trimmed = false;

	// Trim left        
	for (i = 0; i < in_string.length; i++)
	{
		if (in_string.charAt(i) != " ")
		{
			in_string = in_string.substring(i, in_string.length);
			trimmed = true;
			break;
		}
	}
	if (trimmed == false)
		in_string = "";
	return in_string;
}

//=============================================================================================
//===== Enlève les espaces de droite d'une string =============================================
//=============================================================================================
function trim_right(in_string)
{
	for (i = in_string.length - 1; i >= 0; i--)
	{
		if (in_string.charAt(i) != " ")
		{
			in_string = in_string.substring(0, i+1);
			break;
		}
	}
	return in_string;
}

//===================================================================================================================================
//===== Fonction qui vérifie l'existence d'expression se référant à des instances externes ==========================================
//===================================================================================================================================
//===== Il est important de noter que cette fonction doit être bien utilisée, sinon elle peut neutraliser le fonctionnement du ======
//===== programme actif. Cette fonction devrait seulement être utilisée, lorsqu'on interagit avec des objets/expressions/fonctions ==
//===== qui originent ou font appel à un autre cadre que celui où ils sont exécutés. ================================================
//===================================================================================================================================
//===== L'appel de la fonction comprend les paramètres suivants : ===================================================================
//===================================================================================================================================
//===== execWhenExist(sExpression, iCheckSpecs, sDelimiter, iRetry) =================================================================
//===== sExpression (string) : Obligatoire, doit comprendre l'expression à exécuter, elle doit être manuellement divisée par les ====
//=====						   délimiteurs prévus à cet effet.																	 ====
//=====	iCheckSpecs (integer) : Facultatif, spécifie à la fonction quelle parties de l'expression doivent être testées.          ====
//=====							Options --- EXECWHENEXIST_EVAL_ALL; Toute l'expression est évaluée.								 ====
//=====										EXECWHENEXIST_SKIP_FIRST_AND_LAST; Tout sauf le premier et le dernier élément de     ====
//=====										l'expression est évalué.															 ====
//=====										EXECWHENEXIST_SKIP_FIRST; Tout sauf le premier élément de l'expression est évalué.   ====
//=====										EXECWHENEXIST_SKIP_LAST; Élément par défaut si omis, tout sauf le dernier élément    ====
//=====										de l'expression est évalué.															 ====
//===== sDelimiter (string) : Facultatif, le caractère à utiliser qui servira de délimiteur d'expressions partielles.            ====
//===== iRetry (integer) : INTERNE SEULEMENT, le nombre de boucles de vérification à faire si l'expression partielle évaluée est ====
//=====					   non-existente. Elle est généralement utilisée dans l'appel récursif de la fonction et l'on y attribue ====
//=====					   la valeur par défaut de 5 boucles.																	 ====
//===== sExecExpr (string) : Facultatif, la chaîne de caractères qui y sera passée consistera en une instruction qui sera  		 ====
//=====					   exécutée dans le cas où la première expression est existente.										 ====
//===================================================================================================================================
//===== Notes d'utilisation : =======================================================================================================
//===================================================================================================================================
//===== 1. Dans le cas de l'utilisation de la fonction dans une définition de variable, on se voit forcé de faire l'appel d'une =====
//===== variable globale afin d'assurer son accessibilité dans cette fonction. ======================================================
//===== Alors : var abc = getFrame('titre').document.images(23).src =================================================================
//===== Deviendra : execWhenExist("document.abc = |getFrame('titre')|.document|.images(23)|.src"); ==================================
//===================================================================================================================================
//===== 2. Les fonctions exécutées doivent être autonomes. On doit inclure toute l'expression au complet en paramètre dans       ====
//===== l'appel de la fonction. =====================================================================================================
//===================================================================================================================================
//==== 3. Afin d'utiliser des valeurs de variables contenues dans les expressions, on doit inclure littéralement les valeurs     ====
//==== actuelles de celles-ci pour assurer la transférabilité des valeurs dans la fonction.										 ====
//==== Ex. : execWhenExist("getFrame('titre')|.document|.abc_form|.abc_field|.value = '" + VARIABLE + "'", EXECWHENEXIST_EVAL_ALL) ==
//===================================================================================================================================
//==== 4. Il est nécessaire d'être vigilant lors de la détermination des éléments à vérifier à l'intérieur de l'expression. =========
//==== Exemples : ===================================================================================================================
//==== Appel de fonction : getFrame('lmain')|.doRefresh|('CONTINUOUS') ; La dernière particule contenant les paramètres ne doit  ====
//====											pas être vérifiée, alors EXECWHENEXIST_SKIP_LAST sera approprié dans ce cas.	 ====
//===================================================================================================================================
//==== Affectation : document.form.value = |getFrame('titre')|.document|.form2|.value ; Tout ce qui est avant le signe égal doit ====
//==== être négligé + Le dernier élément 'value' est non-nécessaire à vérifier. EXECWHENEXIST_SKIP_FIRST_AND_LAST est approprié. ====
//==== Affectation # 2 : getFrame('footer')|.form|.field|.value = '2' ; On veut simplement vérifier l'existence du champ du      ====
//====						formulaire.  On ne doit pas tester l'affection elle-même. EXECWHENEXIST_SKIP_LAST est approprié.	 ====
//===================================================================================================================================
var EXECWHENEXIST_EVAL_ALL = 0;
var EXECWHENEXIST_SKIP_FIRST_AND_LAST = 1;
var EXECWHENEXIST_SKIP_FIRST = 2;
var EXECWHENEXIST_SKIP_LAST = 3;

function execWhenExist()
{

	// Délai à respecter pour un nouvel essai (millisecondes)
	var TIMER_DELAY = 1000;
	// Nombre d'essais
	var RETRIES = 5;
	var sPartialExpression = "";
	var sFullExpression = "";
	var aRawExpression = new Array();
	var aTestExpression = new Array();
	var bError = false;
	var iRawExprIdx = 0;
	var iTestExprIdx = 0;
	var iRetry = 1;
	var evalReturn;
	var sDelimiter;
	var sExecExpr;
	
	//------------------------------------------------------------------------------------------------------------------
	//----- Extraction de paramètres -----------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------

	// Prélever la string à exécuter
	var sExpression = execWhenExist.arguments[0];
	var iCheckSpecs;
	// Vérifier la dernière partie de l'expression?
	if (execWhenExist.arguments[1] == null)
		iCheckSpecs = EXECWHENEXIST_SKIP_LAST;
	else
		iCheckSpecs = execWhenExist.arguments[1];
 	// Séparateur d'expressions partielles à utiliser	
	if (execWhenExist.arguments[2] == null)
		sDelimiter = "|";
	else
		sDelimiter = execWhenExist.arguments[2];
	// De quel essai s'agit-il?
	if (execWhenExist.arguments.length>3)
		iRetry = execWhenExist.arguments[3];
	// Expression à exécuter en cas de succès?
	if (execWhenExist.arguments.length==5)
		sExecExpr = execWhenExist.arguments[4];
	
	//------------------------------------------------------------------------------------------------------------------
	//----- Remplissage des vecteurs -----------------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------
	// Tronquer l'expression à l'aide des délimiteurs	
	aRawExpression = sExpression.split(sDelimiter);
	
	// Boucle qui sert à remplir notre vecteur contenant l'expression à tester.
	for (iRawExprIdx=0; iRawExprIdx<aRawExpression.length; iRawExprIdx++)
	{
		if (iRawExprIdx==0 && iCheckSpecs!=EXECWHENEXIST_SKIP_FIRST && iCheckSpecs!=EXECWHENEXIST_SKIP_FIRST_AND_LAST)
			aTestExpression[aTestExpression.length] = aRawExpression[iRawExprIdx];
			
		else if (iRawExprIdx==aRawExpression.length-1 && iCheckSpecs!=EXECWHENEXIST_SKIP_LAST && iCheckSpecs!=EXECWHENEXIST_SKIP_FIRST_AND_LAST)
			aTestExpression[aTestExpression.length] = aRawExpression[iRawExprIdx];
			
		else if (iRawExprIdx!=0 && iRawExprIdx!=aRawExpression.length-1)
			aTestExpression[aTestExpression.length] = aRawExpression[iRawExprIdx];
			
		// Concaténer les expressions partielles au fur et à mesure
		sFullExpression += aRawExpression[iRawExprIdx];
	}

	//------------------------------------------------------------------------------------------------------------------
	//----- Tester l'expression par étapes -----------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------
	// Boucler tant qu'il n'y a pas d'erreur et que nous sommes pas au bout de l'expression
	while (!bError && iTestExprIdx<aTestExpression.length)
	{
		// Concaténer les expressions partielles au fur et à mesure
		sPartialExpression += aTestExpression[iTestExprIdx];
		evalReturn = eval(sPartialExpression);

		// Si l'expression n'est pas valide/existante, exécuter le contenu du test
		if (!evalReturn)
			bError = true;

		// Incrémenter l'index de la boucle
		iTestExprIdx++;
	}

	//------------------------------------------------------------------------------------------------------------------
	//----- Rappel récursif de la fonction -----------------------------------------------------------------------------
	//------------------------------------------------------------------------------------------------------------------

	//--- Rappel récursif si ERREUR et PAS DERNIER ESSAI ----------------------------
	if (bError && iRetry<=RETRIES)
	{		
		// Prochain essai
		iRetry++;
		// Convertir l'expression d'une façon littérale
		sExpression = ConvertToJavaLiteral(sExpression);
		// Après le délai prescrit, rappeller la fonction récursivement.
		setTimeout('execWhenExist("' + sExpression + '", ' + iCheckSpecs + ', "' + sDelimiter + '", ' + iRetry + ', "' + sExecExpr + '")',TIMER_DELAY);
	}
	//--- Évaluer toutes l'expression si PAS ERREUR ----------------------------------
	else if (!bError)
	{
		// Retourner l'objet en question s'il existe ou 'undefined' s'il n'existe pas.
		evalReturn = eval(sFullExpression);

		// --- Si EXPRESSION DIFFÉRENTE à EXÉCUTER en cas de SUCCÈS ----------------
		if ((sExecExpr!=null || sExecExpr!="") && evalReturn)
			eval(sExecExpr);

		return evalReturn;
	}
	//--- Si ERREUR retourne NULL -----------------------------------------------------
	else
		return null;
}

//====================================================================================================
//=== Cette fonction TRANSFORME un PATH pour qu'il FONCTIONNE avec EXECWHENEXIST ("." devient "|." ===
//====================================================================================================
function getExecWhenExistCompatiblePath(path)
{
	var aElements = path.split('.');
	path = '';
	for (var i=0; i<aElements.length; i++)
	{
		path += aElements[i];
		if (i < aElements.length-1)
			path += '|.';
	}
	return path;
}

//======================================================================================================================
//=====  * Cette fonction retourne un délimiteur qui ne rentre pas en conflit avec la valeur d'une variable  ===========
//======================================================================================================================
function getDelimiter(sPartialExpression)
{
	if (sPartialExpression.indexOf("|")==-1)
		return "|";
	else
		if (sPartialExpression.indexOf("~")==-1)
			return "~";
		else
			if (sPartialExpression.indexOf("#")==-1)
				return "#";
}

//======================================================================================================================
//=====  * Cette fonction permet de convertir une string de manière a ce qu'elle puisse etre insérer entre ""  =========
//=====  * dans un programme Java ou Javascript. Ainsi, les \ sont dédoublés et les " sont préfixés d'un \     =========
//=====  * Exemple:                                                                                            =========
//=====  *   Mon poids\grandeur est 123lbs/5'9"																   =========
//=====  * donne:																							   =========
//=====  *   Mon poids\\grandeur est 123lbs\\5'9\"															   =========
//======================================================================================================================
function ConvertToJavaLiteral(sExpression)
{
    if (sExpression.length==0)
        return sExpression;
 
    iLength = sExpression.length;
    // Dédoubler les \
    for (position=0; position<iLength; position++)
    {
      if (sExpression.charAt(position)=="\\")
      {
        sExpression = sExpression.substring(0, position) + "\\\\" + sExpression.substring(position+1);
        iLength++;
        position += 2;				
      }
      // Insérer un \ avant les " 
      else if (sExpression.charAt(position) == "\"")
      {
        sExpression = sExpression.substring(0, position) + "\\\"" + sExpression.substring(position+1);
        iLength++;
        position++;
      }
    }
    return sExpression;
}

//===============================================================
//==== Cette fonction permet d'extraire les paramètres d'une 
//==== querystring de la manière suivante. Pour extraire le 
//==== paramètre "client_nri=123" de la querystring courante:
//====        var arg = getArgs();
//====        alert(arg.client_nri);  // Affiche "123"
//===============================================================
function getArgs() 
{
	var args = new Object();
	// Get Query String
	var query = location.search.substring(1); 
	// Split query at the comma
	var pairs = query.split("&"); 
	
	// Begin loop through the querystring
	for(var i = 0; i < pairs.length; i++) 
	{
		// Look for "name=value"
		var pos = pairs[i].indexOf('='); 
		// if not found, skip to next
		if (pos == -1) 
		{
			args[argname] = null; 
			continue
		}
		// Extract the name
		var argname = pairs[i].substring(0,pos); 
		
		// Extract the value
		var value = pairs[i].substring(pos+1); 
		// Store as a property
		args[argname] = unescape(value);
	}
	return args; // Return the Object
}

//===========================================================================
//==== Cette fonction permet d'identifier si un paramètre est existant
//====  http://machine:80/url?abc=20&def=10&ghi&jkl=1
//==== argExists(def) retournera TRUE / argExists(xyz) retournera FALSE
//===========================================================================
function argExists(argToFind) 
{
	var args = new Object();
	// Get Query String
	var query = location.search.substring(1); 
	// Split query at the comma
	var pairs = query.split("&"); 
	var pos;
	var argname;
	
	// Begin loop through the querystring
	for(var i = 0; i < pairs.length; i++) 
	{
		if (pairs[i].indexOf('=')!=-1)
		{
			// Look for "name=value"
			pos = pairs[i].indexOf('='); 
			// Extract the name
			argname = pairs[i].substring(0,pos); 
		}
		else
			argname = pairs[i]; // Extract the name
			
		if (argname.toUpperCase()==argToFind.toUpperCase())
			return true; // Return the Object
	}
	
	return false; // Loop finished, return not found value...
}

//===========================================================================
//=== REMPLACE la VALEUR d'un PARAMÈTRE dans une URL ========================
//===========================================================================
function changeArg(url, paramName, paramValue)
{
	var finalUrl = "";
	var splittedUrl = url.split("?");
	var bParamChanged = false;

	//--- Ajouter la PREMIÈRE PARTIE de l'URL (ex: /servlet/SSSites?) ----------
	finalUrl += splittedUrl[0]+"?";
	//--- Ajouter la DEUXIÈME PARTIE de l'URL (ex: ?site_nri=1234) -------------
	if (splittedUrl[1]!=null)
	{
		var aParams = splittedUrl[1].split("&"); 
		for (var i=0; i<aParams.length; i++)
		{
			var aParam = aParams[i].split("="); 
			// Ajouter le NOM du PARAMÈTRE
			finalUrl += aParam[0]+"="; 
			// Ajouter la VALEUR du PARAMÈTRE
			if (aParam[1]!=null && aParam[1]!='')
			{
				// Paramètre à modifier
				if (aParam[1]==paramName)
				{
					finalUrl += paramValue;
					bParamChanged = true;
				}
				// Paramètre inchangé
				else
					finalUrl += aParam[1];
			}
			finalUrl += "&";
		}
	}
	//--- PARAMÈTRE toujours PAS CHANGÉ? L'AJOUTER! ----------------------------
	if (!bParamChanged)
		finalUrl += paramName+"="+paramValue;
	//--- RETIRER le DERNIER CARACTÈRE si INVALIDE -----------------------------
	var urlLastChar = finalUrl.substring(finalUrl.length-1, finalUrl.length);
	if (urlLastChar=="&" || urlLastChar=="?")
		finalUrl = finalUrl.substring(0, finalUrl.length-1);

	return finalUrl;
}

//===========================================================================
//=== COPIE le HTML d'un ÉLÉMENT d'une FRAME À UNE AUTRE ====================
//===========================================================================
function copyHtmlContent(sourceDoc, sourceId, destinationDoc, destinationId)
{
	var oSource = sourceDoc.getElementById(sourceId);
	var oDestination = destinationDoc.getElementById(destinationId);
	oDestination.innerHTML = oSource.innerHTML;
}

//===========================================================================
//=== FUSIONNER DEUX TABLEAUX DE PROPRIÉTÉS =================================
//===========================================================================
function mergePropertyArrays(p1, p2)
{
	// ATTENTION: p1.length sera toujours 0 car c'est un ARRAY DE PROPRIÉTÉS.
	//            Il faut compter les éléments avec for (var names in p1)
	var finalArray = new Array();
	for (var names in p1)
		finalArray[names] = p1[names];
	for (var names in p2)
		finalArray[names] = p2[names];
	return finalArray;
}

//===========================================================================
//=== VÉRIFIE si un TABLEAU DE PROPRIÉTÉS EST VIDE ==========================
//===========================================================================
function isPropertyArrayEmpty(aArray)
{
	for (var names in aArray)
		return false;
	return true;
}

// ======================================================================
// Cette fonction permet de CHANGER le CURSEUR de l'interface
// Optimisée par GG le 29/06/2004
// ======================================================================
function changeCursor(frameset, cursorStyle)
{
	var i;
	var j;
	var frame;
	var ext;

	// ----- Netscape 4 ne SUPPORTE PAS CHANGEMENT DE CURSEUR --------------------------------
	if (document.layers != null)
		return null;

	// ---------------------------------------------------------------------------------------
	// ----- PAS DE FRAMES -------------------------------------------------------------------
	// ---------------------------------------------------------------------------------------
	if (frameset.length == 0)
	{
		// Document WORD ou PDF - Ne RIEN FAIRE (BUG FIX)
		ext = frameset.location.href.substring(frameset.location.href.length-3, frameset.location.href.length).toLowerCase();
		if (ext != 'doc' && ext != 'pdf')
		{	
			// Changer curseur du BODY
			if (frameset.document.body != null)
				frameset.document.body.style.cursor = cursorStyle;

			// Changer curseur des FORMULAIRES
			if (frameset.document.forms != null)
				for (j = 0; j < frameset.document.forms.length; j++)
					frameset.document.forms[j].style.cursor = cursorStyle;
		}
	}
	// ---------------------------------------------------------------------------------------
	// ----- FRAMES --------------------------------------------------------------------------
	// ---------------------------------------------------------------------------------------
	else
	{
		// Changer curseur de TOUTES LES FRAMES
		for (i = 0; i < frameset.length; i++)
		{
			// TRY --> BUG FIX pour WinXP SP2 (obtient des fois "Access Denied" dans fenêtre document)
			try
			{
				// VÉRIFIER que ce ne soit PAS un document WORD ou un PDF (BUG FIX)
				ext = frameset[i].location.href.substring(frameset[i].location.href.length-3, frameset[i].location.href.length).toLowerCase();
				if (ext != 'doc' && ext != 'pdf')
				{
					// ----- PAS DE FRAMES -------------------------------------------------------------
					if (frameset[i].length == 0)
					{
						frame = frameset[i].document;
						if (frame != null)
						{
							// Changer curseur du BODY
							if (frame.body != null)
								frame.body.style.cursor = cursorStyle;
		
							// Changer curseur des FORMULAIRES
							if (frame.forms != null)
								for (j = 0; j < frame.forms.length; j++)
									frame.forms[j].style.cursor = cursorStyle;
						}
					}
					// ----- FRAMES --------------------------------------------------------------------
					else // Recursivite
						changeCursor(frameset[i], cursorStyle);
				}
			}
			catch (e)
			{
				window.status = "changeCursor() can't change cursor in the '" + frameset[i].name + "' frame (WinXP-SP2).";
				continue;
			}
		}
	}
}

// ======================================================================
// Cette fonction permet de CHANGER le CURSEUR de l'interface
// En remontant toutes les fenêtres ouvertes jusqu'à l'original
// (original top).
// ======================================================================
function changeCursorInOpenedWindows(cursorStyle)
{
	var oWin = window.top;
	var oOriginalTop = eval(getOriginalTop());
	var bDone = false;
	while (!bDone)
	{
		changeCursor(oWin, cursorStyle);
		if (oWin!=oOriginalTop && oWin.top.opener)
			oWin=oWin.top.opener.top;
		else
			bDone=true;
	} 	
}

// ======================================================================
// DÉFINI les VALEURS des CHAMPS d'une SÉLECTION MULTIPLE
// ======================================================================
function setMultiSelection(nrisField, descsField, textDescsField, aNriValues, aDescValues, bAppendValues, language)
{
	// ------------------------------------------------
	// ----- RÉ-INITIALISER LES CONTRÔLES -------------
	// ------------------------------------------------
	if (!bAppendValues)
	{
		// ----- VIDER le CHAMP des NRIS ----------------
		nrisField.value = "";
		
		// ----- VIDER le COMBO BOX des DESCRIPTIONS ----
		for (var i = descsField.length-1; i >= 0; i--)
			descsField.options[i] = null;
		
		// ----- VIDER le CHAMP TEXTE des DESCS ---------
		if (textDescsField != null)
			textDescsField.value = "";
	}

	// ------------------------------------------------
	// ----- SORTIR si PAS DE VALEURS -----------------
	// ------------------------------------------------
	if (aNriValues == null || aDescValues == null)
		return;

	// ------------------------------------------------
	// ----- UNESCAPE du champ TEXTE pour AJOUTS ------
	// ------------------------------------------------
	if (textDescsField != null)
		textDescsField.value = unescape(textDescsField.value);
			
	// ------------------------------------------------
	// ----- AJOUTER les VALEURS ----------------------
	// ------------------------------------------------
	// Créer un ARRAY des NRIS SÉLECTIONNÉS à partir du champ texte
	var aSelNriValues = getArrayFromString(nrisField.value, NRIS_SEPARATOR);
	// Créer un ARRAY des DESCRIPTIONS SÉLECTIONNÉES à partir du champ texte ESCAPÉ										
	var aSelDescsValues = getArrayFromString(textDescsField.value, DESCS_SEPARATOR);
	// SÉLECTIONNER les VALEURS AJOUTÉES? (controle LIST)
	var bSelectNewElements = (bAppendValues && descsField.size > 1 && descsField.multiple);
	if (bSelectNewElements)
		descsField.selectedIndex = -1; // Effacer sélection courante

	for (var i = 0; i < aNriValues.length; i++)
	{
		if (aNriValues[i] == null || aNriValues[i] == '')
			continue;

		// ---------------------------------
		// ----- VÉRIFIER DOUBLONS ---------
		// ---------------------------------
		var bAddValue = true; // Par défaut
		for (var j = 0; (aSelNriValues!=null && j<aSelNriValues.length); j++)
		{
			if (aSelNriValues[j] != null && aSelNriValues[j] == aNriValues[i] &&
					aSelDescsValues[j] != null && aSelDescsValues[j] == aDescValues[i])
			{
				bAddValue = false;
				break; // Sortir du 'for'
			}
		}

		// ----------------------------------------------
		// ----- PAS UN DOUBLON - AJOUTER LA VALEUR -----
		// ----------------------------------------------
		if (bAddValue)
		{
			// ----------------------------------------------------------------------------
			// ----- AJOUTER la VALEUR au champ des NRIS (séparés par NRIS_SEPARATOR) -----
			// ----------------------------------------------------------------------------
			nrisField.value += NRIS_SEPARATOR + aNriValues[i];
	
			// -----------------------------------------------------------------
			// ----- AJOUTER la VALEUR au COMBO BOX/LISTE des DESCRIPTIONS -----
			// -----------------------------------------------------------------
			addToMultiSelectionCtrl(descsField, aNriValues[i], aDescValues[i], language, bSelectNewElements);
	
			// --------------------------------------------------------------------------------------------
			// ----- AJOUTER la VALEUR au champ TEXTE des DESCRIPTIONS (séparées par DESCS_SEPARATOR) -----
			// --------------------------------------------------------------------------------------------
			if (textDescsField != null)
				textDescsField.value += DESCS_SEPARATOR + aDescValues[i];
		}
	}

	// ---------------------
	// ----- RAFFINAGE -----
	// ---------------------
	// RETIRER PREMIER NRIS_SEPARATOR du champ des nris
	if (nrisField.value.substring(0,NRIS_SEPARATOR.length)==NRIS_SEPARATOR)
		nrisField.value = nrisField.value.substring(NRIS_SEPARATOR.length);

	if (textDescsField != null)
	{
		// RETIRER PREMIER DESCS_SEPARATOR du champ texte des descriptions
		if (textDescsField.value.substring(0,DESCS_SEPARATOR.length)==DESCS_SEPARATOR)
			textDescsField.value = textDescsField.value.substring(DESCS_SEPARATOR.length);
		// ESCAPER le champ texte des descriptions
		textDescsField.value = escape(textDescsField.value);
	}
}

// ======================================================================
// AJOUTE un ÉLÉMENT au CONTROLE d'une sélection MULTIPLE
// ======================================================================
function addToMultiSelectionCtrl(ctrl, value, text, language, bSelect)
{
	// ------------------------------------------------
	// ----- LEXIQUE MULTILINGUE ----------------------
	// ------------------------------------------------
	language = language - 1; // Pour compatibilité avec les vecteurs des libellés
	if (language!='0' && language!='1' && language!='2' && language!='4')
		language='1'; // Anglais par défaut
	var LBL_MULTIPLE_SELECTION = ["* Sélection multiple *",
									"* Multiple Selection *",
									"* Multiple Selection *",
									"",
									"* Selección múltiple *"]; // (TBT)
	// ------------------------------------------------

	var newIndex = ctrl.length;
	
	// ----- Insérer "Multiple Selection" (pour COMBO BOX seulement) -----
	if (newIndex==1 && ctrl.size<2)
	{
		var tempOption = ctrl.options[0];

		ctrl.options[0] = new Option(LBL_MULTIPLE_SELECTION[language], null);
		ctrl.options[1] = tempOption;

		newIndex++;
	}

	// ----- AJOUTER l'élément au CONTROLE -----
	ctrl.options[newIndex] = new Option(text, value);

	// Se POSITIONNER sur le PREMIER ELEMENT (pour COMBO BOX seulement - pour afficher "Multiple Selection")
	if (ctrl.size < 2)
		ctrl.selectedIndex = 0;
	// SÉLECTIONNER l'élément AJOUTÉ (pour LISTE seulement)
	else if (ctrl.size > 1 && bSelect)
		ctrl.options[newIndex].selected = true;
}

// ======================================================================
// RETIRE des VALEURS des CHAMPS d'une SÉLECTION MULTIPLE
// ======================================================================
function removeFromMultiSelection(nrisField, descsField, textDescsField, language)
{
	// ----- EXTRAIRE les VALEURS SÉLECTIONNÉES -------
	var aDescFieldSelNris = getSelectedValues(descsField);
	
	// ------------------------------------------------
	// ----- SORTIR si PAS DE VALEUR À SUPPRIMER ------
	// ------------------------------------------------
	if (aDescFieldSelNris.length == 0)
		return;

	// ------------------------------------------------
	// ----- CRÉER des ARRAYS de TRAVAIL --------------
	// ------------------------------------------------
	// Créer un ARRAY des NRIS à partir du champ texte
	var aSelNriValues = getArrayFromString(nrisField.value, NRIS_SEPARATOR);
	// Créer un ARRAY des DESCRIPTIONS à partir du champ texte ESCAPÉ										
	var aSelDescsValues = getArrayFromString(textDescsField.value, DESCS_SEPARATOR);

	// ------------------------------------------------
	// ----- RETIRER les VALEURS DEMANDÉES ------------
	// ------------------------------------------------
	// Position de l'élément qui sera sélectionné
	var iSelectedPosition = null;

	for (var i = 0; i < aDescFieldSelNris.length; i++)
	{
		for (var j = 0; j < aSelNriValues.length; j++)
		{
			if (aSelNriValues[j] != null && aSelNriValues[j] == aDescFieldSelNris[i])
			{
				// Supprimer l'élément
				aSelNriValues[j] = null;
				aSelDescsValues[j] = null;
				// Position du premier élément supprimé
				if (iSelectedPosition == null)
					iSelectedPosition = j-1;
				// Stopper le 'for'
				break;		
			}
		}
	}

	// -------------------------------------------------------------
	// ----- METTRE À JOUR les CHAMPS de la SÉLECTION MULTIPLE -----
	// -------------------------------------------------------------
	setMultiSelection(nrisField, descsField, textDescsField, aSelNriValues, aSelDescsValues, false, language);
	
	// -----------------------------------------------------------------
	// ----- SÉLECTIONNER l'élément AVANT CELUI qui a été SUPPRIMÉ -----
	// -----------------------------------------------------------------
	if (iSelectedPosition == null || iSelectedPosition == -1) // Premier élément supprimé?
		iSelectedPosition = 0;
	descsField.selectedIndex = iSelectedPosition;
}

// ======================================================================
// Défini la valeur des champs d'une sélection SIMPLE
// ======================================================================
function setSingleSelection(nriField, descField, nriValue, descValue)
{
	// ---------------------------------------------------
	// ----- VIDER CHAMPS et SORTIR si PAS DE VALEUR -----
	// ---------------------------------------------------
	if (nriValue == null || descValue == null)
	{
		nriField.value = "";
		descField.value = "";
	}
	// ---------------------------------------------------
	// ----- DÉFINIR les NOUVELLES VALEURS ---------------
	// ---------------------------------------------------
	else
	{
		var tempArray = getArrayFromString(nriValue, NRIS_SEPARATOR);
		// ----- ARRAY - UTILISER PREMIER ELEMENT --------
		// NB: Il est possible de recevoir un Array car si l'usager a sélectionné un élément
		//     puis l'a désélectionné, il occupera tout de même une place dans l'Array mais cet 
		//     emplacement sera null. Comme on fait ici une sélection simple, trouver le premier
		//     élément de l'Array et l'utiliser comme sélection.
		if (tempArray!=null && tempArray.length>1) // Ne PAS tester sur nriValue car 'length' fonctionne même si c'est une string
		{
			for (var i=0; i<nriValue.length; i++)
			{
				if (nriValue[i]!=null)
				{
					nriField.value = nriValue[i];
					descField.value = descValue[i];
					break;
				}
			}
		}
		// ----- VALEUR NORMALE --------------------------
		else
		{
			nriField.value = nriValue;
			descField.value = descValue;
		}
	}
}

// ======================================================================
// Convertir une chaîne de caractères en tableau (Array)
// ======================================================================
function getArrayFromString(str, separator)
{
	if (str==null || str=='')
		return null;
	else
	{
		str = unescape(str);
		return str.split(separator);
	}
}

// ======================================================================
// Compte les éléments d'un tableau
// ======================================================================
function getArrayNbElements(aArray)
{
	var iNbElements = 0;
	for (var i=0; (aArray!=null && i<aArray.length); i++)
		if (aArray[i]!=null && aArray[i]!='')
			iNbElements++;
	
	return iNbElements;
}

// ======================================================================
// Détermine la position d'un élément dans un tableau (-1 si absent)
// ======================================================================
function getElementPositionInArray(aArray, element)
{
	for (var i=0; (aArray!=null && i<aArray.length); i++)
		if (aArray[i]!=null && aArray[i]==element)
			return i;
	return -1;
}

// ======================================================================
// Extraire la VALEUR du bouton RADIO sélectionné
// ======================================================================
function getRadioGroupSelectedValue(oRadioBtns)
{
	for (var i = 0; i < oRadioBtns.length; i++)
		if (oRadioBtns[i].checked)
			return oRadioBtns[i].value;

	// ----- AUCUNE SÉLECTION -----
	return null;
}

// ======================================================================
// Extraire l'INDEX d'une valeur d'un bouton RADIO
// ======================================================================
function getRadioGroupValueIndex(oRadioBtns, value)
{
	for (var i = 0; i < oRadioBtns.length; i++)
		if (oRadioBtns[i].value == value)
			return i;
	// ----- VALEUR INTROUVABLE -----
	return -1;
}

// ======================================================================
// Initialiser groupe de boutons RADIO
// ======================================================================
function setRadioGroupBlankValues(oRadioBtns)
{
	for (var i = 0; i < oRadioBtns.length; i++)
		if (oRadioBtns[i].checked)
			oRadioBtns[i].checked = false;

	// ----- AUCUNE SÉLECTION -----
	return null;
}

// ======================================================================
// Extraire l'INDEX d'une valeur d'un COMBO BOX
// ======================================================================
function getComboBoxValueIndex(oComboBox, value)
{
	for (var i = 0; i < oComboBox.length; i++)
		if (oComboBox.options[i].value == value)
			return i;	
	// ----- VALEUR INTROUVABLE -----
	return -1;
}

//======================================================================
// Retire dynamiquement un item d'un combobox 
//======================================================================
function removeItemFromComboBox(oComboBox, index)
{
	oComboBox.options[index] = null;
}

//======================================================================
// Ajoute dynamiquement un item à une combobox 
//======================================================================
function appendItemToComboBox(oComboBox, text, value)
{
	oComboBox.options[oComboBox.length] = new Option(text, value);
}


//======================================================================
//=== Générer TIMESTAMP (pour forcer reload des pages)
//======================================================================
function appendTimestampToQuerystring(url)
{
	var separator = "?";
	if (url.indexOf("?")>-1)
		separator = "&";
	return url+separator+"timestamp="+getTimeStamp();
}

//======================================================================
//=== Générer TIMESTAMP (clé unique dans le temps)  ====================
//======================================================================
function getTimeStamp()
{
	var date = new Date();
	return date.getTime();
}

//==================================================================
//=== VÉRIFIE si un BLOQUEUR de POPUP est ACTIF ====================
//==================================================================
function isPopupBlockingActive()
{
	var tstWin = window.open("/bidon.html", "TestWindow");

	if (tstWin == null)
		return true;
	else
	{
		tstWin.close();
		return false;
	}
}

//=====================================================================
//=== Convertir une string en entier ==================================
//=====================================================================
function getIntValue(sValue, iDefault)
{
	var iValue = iDefault;
	if (sValue!=null && sValue!='')
	{
		try
		{
			iValue = parseInt(sValue);
		}
		catch (e)
		{}
	}
	return iValue;
}

//=====================================================================
//=== CONVERTI une COLLECTION (ex: getElementsByTagName) en ARRAY =====
//=====================================================================
function collectionToArray(coll)
{
	if (coll == null)
		return null;

	var ar = new Array();
	
	for (var i=0; i<coll.length; i++)
		ar[ar.length] = coll[i];

	return ar;
}

//=====================================================================
//=== Compter les items cochés d'un même group de CHECKBOX ============
//=== Paramètre: objet du groupe de checkbox               ============
//===  Ex: getCheckedInGroup(document.form.myGroup);       ============
//=====================================================================
function getNbCheckedInGroup(oChekBoxGroup)
{
	var iNbChecked=0;
	for (var i=0; oChekBoxGroup!=null && i<oChekBoxGroup.length; i++) 
	{
		if (oChekBoxGroup[i].checked==true)
			iNbChecked++;
	}			
	return iNbChecked;
}

//=====================================================================
//=== EXTRAIT les VALEURS SÉLECTIONNÉES d'un <SELECT> =================
//=====================================================================
function getSelectedValues(ctrl)
{
	var aSelValues = new Array();

	for (var i = 0; i < ctrl.options.length; i++) 
		if (ctrl.options[i].selected)
			aSelValues.push(ctrl.options[i].value);
			
	return aSelValues;
}

//=====================================================================
//=== Cacher un élément (ex: input, table, div, etc...) ===============
//=====================================================================
function hideElement(oElement)
{
	if (oElement!=null)
	{
		oElement.style.visibility='hidden';
		oElement.style.position='absolute';
		oElement.style.width='1px';
		oElement.style.height='1px';
		oElement.style.zIndex='1';
	}
}

//=====================================================================
//=== Montrer un élément (ex: input, table, div, etc...) ==============
//=====================================================================
function showElement(oElement)
{
	if (oElement!=null)
	{
		oElement.style.visibility='visible';
		oElement.style.position='static';
		oElement.style.width='';
		oElement.style.height='';
		oElement.style.zIndex='';
	}
}

//==========================================================================
//=== Ajoute caractères pour que la chaîne soit de la longueur spécifiée ===
//==========================================================================
function padLeft(str, finalLength, padChar)
{
	var finalStr = "";
	var iNbMissingChars = finalLength-str.length;

	//--- VALIDATION ------------------------------
	if (iNbMissingChars<=0)
		return str;

	//--- AJOUTER CARACTÈRES MANQUANTS ------------
	for (var i=0; i<iNbMissingChars; i++)
		finalStr += padChar;

	//--- AJOUTER CHAINE ORIGINALE ----------------
	finalStr += str;	
	return finalStr;
}