/**
 *
 * Library "Client side control"
 *
 * @author	Iorga
 * @version	3.0
 * @updated	31/01/2002
 *
 * Historique des modifications
 *
 *	11/02/2002	Si on vide un SelectHelper alors on sélectionne le premier élément de sa liste associée.
 *	14/02/2002	Ajout du support de formats pour la saisie des dates
 *	18/02/2002	Ajout de la méthode checkOnChangeEmail()
 *				Ajout du trimming des champs texte avant validation
 *				Gestion des "Assistants" dynamiques
 *	19/02/2002	Gestionnaire d'affichage des dialogue-box (ShowModalDialog)
 *	22/02/2002	Gestionnaire onKeyPress par défaut
 *				Gestion des caractères autorisés/interdits
 *				Ajout du simulateur de OnChange sur les SELECTs afin de synchroniser correctement les Helpers
 *	27/02/2002	Correction bug de transformation en MAJUSCULE des caractères accentués
 *	01/03/2002	Renommage des variables nommées "i" (bug sur doOnLoadSystem).
 *				Modification de AfficherAssistant(): on ne traite pas les valeurs retournées "null"
 *	05/03/2002	Ajout du support de l'événement "ONCHANGEIORGA" remplacant l'événement "onChange" qui ne peut pas être
 *				utilisé. De plus on peut donc ajouter un onChange qui fonctionne sur les listes déroulantes
 *	07/03/2002	Transformation automatique des événement "OnChange" en pseudo-événement "ONCHANGEIORGA"
 *	13/03/2002	Ajout de la gestion des retour d'erreur serveur "showApplicationError()"
 *	15/03/2002	Ajout du support de l'affichage des erreurs clients dans une zone (span) réservée. Pseudo-attribut "ERRORDISPLAYZONE" sur le "BODY"
 *				Utilisation d'un attribut dynamique "ERRORTEXT" pour le stockage du texte de l'erreur cliente (anciennement stocké dans "title").
 *				Cela permet d'utiliser l'attribut "title" librement.
 *	18/03/2002	On n'active pas le bouton par défaut si l'on tape "Entrée" sur un textarea.
 *				Ajout du support d'une valeur de retour pour la fonction "afficherDialogue()"
 *	19/03/2002	Affichage forcé et automatique du logo par défaut.
 *	20/03/2002	Modification de la fonction qui force l'affichage du logo par défaut (Rajout d'un try catch).
 *				Ajout du support des format "MM", "AA" et "AAAA" pour la saisie des dates.
 *				Ajout, lors du link des événements, on vérifie que la valeur du helper existe dans la liste associée.
 *	21/03/2002	Correction du bug de non prise en compte de la modification d'un champ si appui sur "entrée" avec activation de "DEFAULTBUTTON"
 *				Ajout de l'appel automatique d'une fonction de personnalisation doOnFocus() sur l'événement onFocus.
 *	26/03/2002	Modification et renommage de la fonction "checkDateDebutFin()" en "checkPeriode()". On passe en paramètre des objets HTML
 *				Sur la méthode "internal_formKeyPressForAction()" On appelle la méthode "click()" du bouton par défaut
 *				après 100 ms pour permettre au navigateur de se synchroniser (bug sur les objets SELECT avec assistant).
 *				(Bug)On n'active plus le bouton par défaut lorsque l'on frappe entrée sur un autre bouton !
 *	02/04/2002	Ajout du format de saisie "TIMEFIELD", qui autorise la saisie contrôlée d'heures au format "HH:MI"
 *				Ajout de la fonction de vérification de périodes basées sur les heures
 *	15/04/2002	Ajout de la fonction utilitaire relativeDate() et relativeDateAsString()
 *	16/04/2002	Ajout de la fonction utilitaire stringToJSDate()
 *	17/04/2002	Ajout de la fonction initSelect()
 *	19/04/2002	Ajout du support d'un style spécifique à la signalisation des erreurs sur les champs vides.
 *	23/04/2002	On efface la zone d'affichage des erreurs avant vérification du status
 *				Mise en majuscule automatique du type de champ "EMAILFIELD"
 *  14/05/2002  Modification de checkPeriode() pour qu'elle retourne false si une erreur et non l'etat de setErrorIndicator
 *	15/05/2002	Mémorisation de la classe d'un input en attribut lors de l'initialisation afin de restituer la bonne classe
 *				lors de la correction d'une erreur ou pour les checkbox et les radios boutons
 *  28/05/2002  G.S : Rajout de la fonction assignNumbers(evenement) pour activer les numériques à la place des caractères spéciaux
 *	22/07/2002	Modification fonction : internal_formKeyPressForAction() afin d'éviter d'activer le bouton par défaut si appui de <Entrée> sur un HREF
 *	30/09/2002	Correction de bug de limitation interactive de la saisie ("internal_checkMaxSize")
 *
 *
 *	$Log$
 *	Revision 1.1.2.2  2003/10/27 18:51:00  fprevost
 *	Suite de l'ajout du multilangues.
 *	
 *	Revision 1.1.2.1  2003/10/27 10:30:29  fprevost
 *	Ajout du support multi-langue basé sur les préférences du navigateur client (browser).
 *	Utilisation du Translator de la bibliothèque IorgaLib
 *	
 *	Revision 1.3  2003/02/14 08:53:40  fprevost
 *	Correction bug de détection de modification des inputs de type="password".
 *	
 *	Revision 1.2  2002/11/04 13:34:02  fprevost
 *	Suppression du changement automatique du Logo
 *	
 */

/** Constantes  */

var HELPERKEYCODE = 13;

/** Variables globales à la page */

var focusedObject = null;
var onFocusSelectedIndex = null;	// Spécial Bug OnChange sur objet SELECT

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *	Méthodes de gestion des erreurs
 *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

var isErrorModeAlert = false;
var KOStyleClassName = "inputfieldonerror";
var KOStyleClassNameEmpty = "inputfieldonerrorempty";
var showErrorZoneID  = null;					// Zone HTML (span) d'affichage des erreurs

/*=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *  Méthodes de modification de carcatères spéciaux par des numériques
 *=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=*/

function assignNumbers(evenement){

	if( evenement == null )     event.keyCode = null;
	else if( evenement == 38  && event.shiftKey ) event.keyCode = 49;
	else if( evenement == 233 && event.shiftKey ) event.keyCode = 50;
	else if( evenement == 34  && event.shiftKey ) event.keyCode = 51;
	else if( evenement == 39  && event.shiftKey ) event.keyCode = 52;
	else if( evenement == 40  && event.shiftKey ) event.keyCode = 53;
	else if( evenement == 45  && event.shiftKey ) event.keyCode = 54;
	else if( evenement == 232 && event.shiftKey ) event.keyCode = 55;
	else if( evenement == 95  && event.shiftKey ) event.keyCode = 56;
	else if( evenement == 231 && event.shiftKey ) event.keyCode = 57;
	else if( evenement == 224 && event.shiftKey ) event.keyCode = 48;
	else event.keyCode = evenement;

}


/** styleClassErrorModeOn()
 *
 *	Passage de la gestion des erreurs de saisie en mode furtif.
 *	L'affichage d'un message n'a lieu que lors de la vérification.
 */

function styleClassErrorModeOn( styleOK, styleKO ) {

	KOStyleClassName = ((styleKO == null) ? "inputfieldonerror" : styleKO);
	KOStyleClassNameEmpty = KOStyleClassName+"empty";
	isErrorModeAlert = false;
}

/** alertBoxErrorModeOn()
 *
 *	Passage de la gestion des erreurs de saisie en mode alert box.
 */

function alertBoxErrorModeOn() {
	isErrorModeAlert = true;
}

/** setErrorIndicator()
 *
 *	Gérer l'affichage de l'indicateur de saisie erronée en fonction du mode choisi
 *
 *	@param	theFieldObj handle du champ en erreur
 *	@param	texte de l'erreur à afficher
 */

function setErrorIndicator( theFieldObj, theErrText, bForceFurtif ) {

	var bModeAlert = ((bForceFurtif == null)) ? isErrorModeAlert : false ;

	if (theFieldObj.type == "text" & theFieldObj.value == "") {
		theFieldObj.className = KOStyleClassNameEmpty;
	} else {
		theFieldObj.className = KOStyleClassName;
	}

	theFieldObj.setAttribute( "ERRORTEXT", theErrText );

	if (bModeAlert) {

		alert(theErrText);

		theFieldObj.select();
		theFieldObj.focus();

		return false;

	} else {
		return true;
	}
}

function clearErrorIndicator( theField) {

	theField.className = theField.getAttribute("ORIGINALCLASSNAME");
	theField.removeAttribute("ERRORTEXT");

	return true;
}


/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *	Méthodes Utilitaires
 *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

/** rTrim()
 *
 *	Méthode de suppression des blancs en fin de saisie (VARCHAR)
 *
 *	@param	chaine à traiter
 *
 *	@return	chaine traitée
 */

function rTrim( theSource ) {

	if (null == theSource ) return "";

	while (theSource.charAt( theSource.length - 1 ) == " " ) {

		theSource = theSource.substring( 0, theSource.length - 1 );

		if (theSource.length == 0)
			return "";
	}

	return theSource;
}

/** strReplaceAll()
 *
 *	Fonction utilitaire de recherche/remplace sur une chaine de caractères
 *
 * @param	la chaine à explorer
 * @param	la chaine recherchée
 * @param	la chaine de remplacement des occurences
 * @return	la chaine traitée
 */

function strReplaceAll( theSource, toFind, replaceWith, bReplaceAll ) {

	if (null == theSource) return "";
	if (bReplaceAll == null) bReplaceAll = true;

	var li_pos = theSource.indexOf( toFind );

	while (li_pos != -1) {

		if (li_pos < theSource.length -1 ) {
			theSource = theSource.substring(0, li_pos ) + replaceWith + theSource.substring(li_pos + 1, theSource.length);
		} else {
			theSource = theSource.substring(0, li_pos );
		}

		if (!bReplaceAll) return theSource;

		li_pos = theSource.indexOf( toFind, li_pos + replaceWith.length );
	}

	return theSource;
}

/** valueIsInSelectBox( )
 *
 *	Recherche un code passé en paramètre dans la liste des éléments d'une liste
 *	déroulante et retourne son index ou -1 si non trouvé
 */

function valueIsInSelectBox( SelectObj, pValue) {

	var cptOpt = 0;

	for (cptOpt = 0; cptOpt < SelectObj.options.length; cptOpt++ ) {

		if (SelectObj.options[cptOpt].value == pValue ) {
			return cptOpt;
		}
	}

	return -1;
}

/** showAllFrameNames()
 *
 *	Affiche la hierarchie des frames
 */

function showAllFrameNames(  doc, level ) {

	var cptFrame = 0;

	if (doc == null) doc = top
	if (doc.frames.length == 0) return;

	for (cptFrame = 0; cptFrame < doc.frames.length; cptFrame++) {

		alert( "Level "+level+" - "+doc.name+".frames["+cptFrame+"].name = "+doc.frames[cptFrame].name );

		showAllFrameNames( doc.frames(cptFrame), level + 1);
	}
}

/** stringToJSDate()
 *
 *	Retourne une date JavaScript à partir d'une chaine avec ou sans siècle
 *
 *	@param	chaine représentant une date au format "JJMMAA" ou "JJMMAAAA"
 *
 *	@return un objet Date Javascript
 */

 function stringToJSDate( strDate ) {

	var theDate = null;
	var jour = parseInt( strDate.substr(0, 2), 10 );
	var mois = parseInt( strDate.substr(2, 2) - 1, 10 );
	var annee = parseInt( strDate.substr(4), 10 );

	if (strDate.length == 8) {
		theDate = new Date( annee, mois, jour );
	}
	else {
		if (annee < 30) {
			theDate = new Date( 2000 + annee, mois, jour );
		} else {
			theDate = new Date( 1900 + annee, mois, jour );
		}
	}
 	return theDate;
 }


/** relativeDate()
 *
 *	Calcule une date relative à la date passée en paramètre
 *
 *	@param	Objet Date de référence
 *	@param 	Unité de calcul parmi ("d", "m", "y")
 *	@param	Delta à ajouter ou soustraire à la date de référence
 *
 *	@return Objet Date relative
 */

function relativeDate( dateObj, unity, delta ) {

	if (dateObj == null) dateObj = new Date();
	unity = unity.toLowerCase();
	delta = 1 * delta;

	if (unity == "d") {
		return new Date( dateObj.getTime() + (24 * 3600 * 1000 * delta)); 						// x fois 1 jour en millisecondes
	}
	else if (unity == "m") {

		if (delta >= 0) {

			var theMonth = dateObj.getMonth() + 1;
			var buffer = theMonth + delta;
			var deltaYear = Math.floor(buffer / 12);
			theMonth = buffer % 12;

			return new Date( dateObj.getFullYear() + deltaYear, theMonth - 1, dateObj.getDate());
		}
		else {
			var theMonth = dateObj.getMonth() + 1;

			var buffer = Math.abs(delta) - theMonth;
			var deltaYear = 0;
			while (buffer >= 0) {
				deltaYear++;
				buffer -= 12;
			}

			theMonth = theMonth - (Math.abs(delta) % 12);
			if (theMonth < 1) theMonth += 12;

			return new Date( dateObj.getFullYear() - deltaYear, theMonth - 1, dateObj.getDate());
		}
	}
	else if (unity == "y") {
		return new Date( dateObj.getFullYear() + delta, dateObj.getMonth(), dateObj.getDate());
	}
	return null;
}

/** relativeDateAsString()
 *
 *	Calcule une date relative à la date passée en paramètre et la retourne au format :
 *		- JJMMAAAA si bCentury
 *		- JJMMAA si non bCentury
 *
 *	@param	Date de référence au format "JJMMAA" ou "JJMMAAAA" (Chaine de caractères)
 *	@param 	Unité de calcul parmi ("d", "m", "y")
 *	@param	Delta à ajouter ou soustraire à la date de référence
 *	@param	indicateur de date avec partie centenaire (2001) ou non (99)
 *
 *	@return Objet Date relative
 */

function relativeDateAsString( strDate, unity, delta ) {

	var bCentury = (strDate.length == 8);

	var result = relativeDate( stringToJSDate(strDate), unity, delta );

	jour = (result.getDate() < 10) ? "0"+result.getDate() : ""+result.getDate();
	mois = ((result.getMonth() + 1) < 10) ? "0"+(result.getMonth() + 1) : ""+(result.getMonth() + 1);

	if (bCentury) {
		return jour+mois+result.getFullYear();
	} else {
		return jour+mois+(""+result.getFullYear()).substring(2);
	}
}

/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *	Méthodes de gestion de la saisie de formulaire
 *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

/** checkFormStatus()
 *
 *	@param	la référence au formulaire à vérifier.
 *	@param	Indique si un test de présence de modifications est nécessaire.
 *
 *	@return	une des valeurs suivantes :
 *				-1 : une cause d'erreur est survenue
 *				 0 : aucune erreur et aucune modification apportée
 *				 1 : aucune erreur et au moins une modification apportée
 *
 *	Historique des modifications
 *
 *		31/01/2002	Version initiale
 *		15/02/2002	Ajout du paramètre "bCheckChange"
 *		25/02/2002	Correction du bug de détection érronée de changement lors de la présence de liste déroulante
 *					Ajout - on ne traite pas les champs "DISABLED"
 *		25/02/2002	Version initiale suite au renommage (checkBeforeSubmit())
 *		23/04/2002	On efface la zone d'affichage des erreurs
 *
 */

function checkFormStatus( theFormObj, bCheckChange ) {

	var MESS_ISREQUIRED = "La saisie de ce champs est obligatoire.";

	var validationRule;
	var isRequired;
	var isRequiredEmpty;
	var objType;
	var cptElement = 0;

	// On efface la zone d'affichage des erreurs
	if (showErrorZoneID != null) {
		showErrorZoneID.innerHTML = "" ;
	}


	if (bCheckChange == null) bCheckChange = true;

	var bmodified = !bCheckChange;

	for (cptElement = 0 ; cptElement < theFormObj.elements.length; cptElement++) {

		objType = theFormObj.elements[cptElement].type;
		
		if ( !theFormObj.elements[cptElement].disabled && (objType == "text" ||
				objType == "select-one" ||
				objType == "select-multiple" ||
				objType == "checkbox" ||
				objType == "textarea" ||
				objType == "radio" ||
				objType == "password")) {
				
			if ( objType == "text" || objType == "password") {
				// Suppression des trailing-blanks
				theFormObj.elements[cptElement].value = rTrim(theFormObj.elements[cptElement].value);
			}

			/**
			 *	Vérification rapide des champs obligatoires
			 *	On se base sur la présence d'un attribut HTML personnalisé nommé "REQUIREDFIELD"
			 *	Si celui-ci est présent alors on vérifie que le champ associé est bien renseigné.
			 *	Dans le cas où celui-ci n'est pas renseigné, alors on affiche le texte associé à l'attribut si défini
			 *	sinon on affiche un message par défaut.
			 */

			isRequired = theFormObj.elements[cptElement].getAttribute("REQUIREDFIELD");

			if (isRequired != null) {

				if (objType == "select") {

					isRequiredEmpty = (theFormObj.elements[cptElement].options.selectedIndex < 1);
				}
				else {
					isRequiredEmpty = (theFormObj.elements[cptElement].value == "");
				}

				if (isRequiredEmpty) {

					if (isRequired.length > 0) {
						alert(isRequired);
					}
					else {
						alert(MESS_ISREQUIRED+" ("+theFormObj.elements[cptElement].name+")");
					}

					theFormObj.elements[cptElement].focus();
					return -1;
				}
			}

			/**
			 *	Vérification de la présence d'erreurs clientes non traitées (corrigées)
			 */

			 if (!isErrorModeAlert && theFormObj.elements[cptElement].className.substring(0,KOStyleClassName.length) == KOStyleClassName) {

			 	alert(theFormObj.elements[cptElement].getAttribute("ERRORTEXT"));
			 	theFormObj.elements[cptElement].focus();

			 	return -1;
			 }

			/**
			 *	Si une règle de validation complexe est définie alors on l'évalue
			 */

			validationRule = theFormObj.elements[cptElement].getAttribute("FIELDVALIDATIONRULE");

			if (validationRule != null) {

				try {

					if (!eval(validationRule)) {

						theFormObj.elements[cptElement].focus();
						return -1;
					}

				} catch(e) {
					alert(e.message);
					return -1;
				}
			}

			if (bCheckChange) {

				/**
				 *	On vérifie qu'au moins une modification a été effectuée
				 *	car cela ne sert à rien de soumettre un formulaire non modifié
				 *	de plus cela peut fosser la date de dernière modification.
				 */

				if (!bmodified) {

					if (objType == "checkbox") {
						if (theFormObj.elements[cptElement].defaultChecked != theFormObj.elements[cptElement].checked ) bmodified = true;
					}
					else if (objType == "radio") {
						if (theFormObj.elements[cptElement].defaultChecked != theFormObj.elements[cptElement].checked ) bmodified = true;
					}
					else if (objType == "select-one" || objType == "select-multiple") {

						var cptOpt = 0;

						for (cptOpt = 0; cptOpt < theFormObj.elements[cptElement].options.length; cptOpt++ ) {

							if (theFormObj.elements[cptElement].options[cptOpt].defaultSelected != theFormObj.elements[cptElement].options[cptOpt].selected ) {
								bmodified = true;
								break;
							}
						}
					}
					else {				
						if (theFormObj.elements[cptElement].defaultValue != theFormObj.elements[cptElement].value ) bmodified = true;
					}
				}
			}
		}
	}

	/** Appel de la méthode facultative de vérification globale
	 *	Cette méthode permet de remplacer si nécessaire les méthode "FIELDVALIDATIONRULE"
	 */

	try {
		if (!doGlobalCheck(theFormObj)) return -1;
	}
	catch(e) {}

	return ((bmodified) ?  1 : 0);
}

/** checkBeforeSubmit(  )
 *
 *	@param	la référence au formulaire à vérifier.
 *	@param	Indique si une modification est indispensable pour retourner true (validation).
 *
 *	@return	true si le contenu du formulaire est correct et modifié afin d'être soumis, false sinon.
 *
 *	Historique des modifications
 *
 *		25/01/2002	Version initiale
 */

function checkBeforeSubmit( theFormObj, bCheckChange ) {
	return (checkFormStatus( theFormObj, bCheckChange ) == 1);
}


/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 *	Méthodes de controle et gestion de la saisie
 *=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/

/** internal_memoOnFocus()
 *
 *	Cette méthode liée à tous les objets des formulaires permet
 *	de mémoriser automatiquement le champs avec le focus.
 *	Ainsi, la référence à ce champ peut être utilisée sur les
 *	événements clavier.
 */

function internal_memoOnFocus() {

	// Attention variable globale
	focusedObject = event.srcElement;
	window.status = "";

	if (focusedObject != null) {

		// Spécial bug
		if (focusedObject.type.substring(0,6) == "select") onFocusSelectedIndex = focusedObject.options.selectedIndex;

		if (focusedObject.className.substring(0,KOStyleClassName.length) == KOStyleClassName) {

			if (showErrorZoneID == null) {
				window.status = focusedObject.getAttribute("ERRORTEXT");
			} else {
				showErrorZoneID.innerHTML = focusedObject.getAttribute("ERRORTEXT");
			}
		} else {
			if (showErrorZoneID != null) {
				showErrorZoneID.innerHTML = "" ;
			}
		}

		// Appel de la fonction de personnalisation.
		try {
			doOnFocus( focusedObject );
		} catch (e) {}
	}

	event.returnValue = true;
}

// Fonction Proxy
function doOnFocus( theFocusedObj ) {
	return true
}

/** internal_checkMaxSize()
 *
 *	Teste si le nombre de caractères maximum autorisés pour la zone actuelle
 *	n'est pas atteint.
 *
 *	@return false si la taille maxi est atteinte
 */

function internal_checkMaxSize() {

	var maxsize = focusedObject.getAttribute("MAXFIELDSIZE");

	if (maxsize != null) {

		maxsize = parseInt( ((maxsize == "") ? "2000" : maxsize ));

		if (focusedObject.value.length + ((event.keyCode == 13) ? 2 : 1) > maxsize  ) {
			alert("Input zone size limited at "+maxsize+" characters.")
			return false;
		}
	}
	return true;
}

/** internal_formKeyPressForAction()
 *
 * @param nom de l'objet button à clicker en cas d'appui sur "Entrée"
 */

function internal_formKeyPressForAction( theButtonObj ) {

	// Actuellement, la touche d'affichage des Assistant
	// est également la touche "enter", donc on traite en fonction
	if (event.keyCode == HELPERKEYCODE) {

		var helperName = event.srcElement.getAttribute("HELPER");
		if (helperName != null) return true;
	}

	if (event.keyCode == 13 & event.srcElement.type != "image" & event.srcElement.tagName.toUpperCase() != "A") {

		// On a appuyé sur la touche "enter"
		// alors, on simule un click sur le bouton par défaut
		// si il est disponible...
		// et que l'on est pas sur un textarea (18/03/2002)

		if (event.srcElement.type == "textarea") return true;

		if (!theButtonObj.disabled) {

			theButtonObj.focus();

			// On appelle la méthode après 100 ms pour permettre
			// au navigateur de se synchroniser (bug sur les objets SELECT avec assistant)
			setTimeout("document.all."+theButtonObj.name+".click()", 100);
		}

		event.keyCode = null;
		event.returnValue = false;
		return false;
	}
	return true;
}


/** internal_checkHelper()
 *
 *	Test si un assistant est rattaché au champ actuel et si la touche d'activation est appuyée.
 *
 *	@return false si la touche est traitée comme la touche d'accès à l'assistant
 */

function internal_checkHelper( theKeyCode ) {

	if (theKeyCode == HELPERKEYCODE) {

		var helperName = focusedObject.getAttribute("HELPER");
		if (helperName == null) return true;

		eval("document.all."+helperName+".focus();");		// Modif 26/03/2002
		eval("document.all."+helperName+".click();");
		return false;
	}
	else {
		return true;
	}
}

/** internal_checkKeyValid()
 *
 *	Teste si nécessaire que la touche appuyée fait partie des touches autorisées
 *
 *	@return false si la touche appuyée ne fait pas partie des touche valide ou n'est pas <entrée>
 */

function internal_checkKeyValid( theKeyCode, validKeysList ) {

	if (validKeysList == null ) validKeysList = focusedObject.getAttribute("VALIDKEY");

	if (validKeysList != null) {

		if ( theKeyCode != 13 && validKeysList.indexOf( String.fromCharCode(theKeyCode) ) == -1 ) {
			return false;
		}
	}
	return true;
}

/** internal_checkKeyInvalid()
 *
 *	Teste si nécessaire que la touche appuyée ne fait pas partie des touches interdites
 *
 *	@return false si la touche appuyée fait partie des touche interdites
 */

function internal_checkKeyInvalid( theKeyCode, invalidKeysList ) {

	if (invalidKeysList == null) invalidKeysList = focusedObject.getAttribute("INVALIDKEY");

	if (invalidKeysList != null) {

		if ( invalidKeysList.indexOf( String.fromCharCode(theKeyCode) ) == -1 ) {
			return false;
		}
	}
	return true;
}


/** checkOnKeyPressDefault()
 *
 *	Gestionnaire par défaut. Ce gestionnaire vérifie :
 *		- si l'on a activé un helper
 *		- si le nombre de caractères maxi n'est pas atteint
 *		- si le caractère entré fait partie de la liste des caractères autorisés
 *		- si le caractère entré ne fait pas partie de la liste des caractères interdits
 *
 *	@return true si le caractère doit être accepté
 */

function checkOnKeyPressDefault() {

	// Est-ce une HelperKey
	if (!internal_checkHelper( event.keyCode )) {
		event.returnValue = false;
		return false;
	}

	// Teste la longueur Maxi
	if (!internal_checkMaxSize()) {
		event.keyCode = null;
		event.returnValue = false;
		return false;
	}

	// Gére-t-on des touches valides
	if (!internal_checkKeyValid( event.keyCode )) {
		event.keyCode = null;
		event.returnValue = false;
		return false;
	}

	// Gére-t-on des touches valides/invalides ?
	if (!internal_checkKeyInvalid( event.keyCode )) {
		event.keyCode = null;
		event.returnValue = false;
		return false;
	}

	event.returnValue = true;
	return true;
}


/**
 * Convertit à la volée le caractère saisi en MAJUSCULE
 */

function changeKeyPressToUpperCase( theKeyCode ) {

	if (theKeyCode > 96 && theKeyCode < 123) {
		return theKeyCode - 32;
	}
	else if (theKeyCode > 231 && theKeyCode < 236) {
		// Traitement des "e" accentués
		return 69;
	}
	else if (theKeyCode > 235 && theKeyCode < 240) {
		// Traitement des "i" accentués
		return 73;
	}
	else if (theKeyCode > 241 && theKeyCode < 247) {
		// Traitement des "o" accentués
		return 79;
	}
	else if (theKeyCode > 248 && theKeyCode < 253) {
		// Traitement des "u" accentués
		return 85;
	}

	return theKeyCode;
}

function checkOnKeyPressToUpperCase() {

	event.keyCode = changeKeyPressToUpperCase( event.keyCode );

	// Tests par défaut
	if (!checkOnKeyPressDefault()) {
		event.returnValue = false;
		return false;
	}

	event.returnValue = true;
	return true;
}

/**
 * Convertit à la volée le caractère saisi en MINUSCULE
 */

function checkOnKeyPressToLowerCase() {

	if (event.keyCode > 64 && event.keyCode < 91) {
		event.keyCode = event.keyCode + 32;
	}

	// Tests par défaut
	if (!checkOnKeyPressDefault()) {
		event.returnValue = false;
		return false;
	}

	event.returnValue = true;
	return true;
}

/**
 * Vérifie à la volée les saisie de Numerique
 */

function checkOnKeyPressToNumeric( bNegatif, bDecimal) {

	if (!internal_checkHelper( event.keyCode )) {
		event.returnValue = false;
		return false;
	}

	if (bNegatif == null || bDecimal == null) {

		var theFormat = focusedObject.getAttribute("NUMERICFIELD");

		if (bNegatif == null) bNegatif = (theFormat.indexOf("-") > -1);
		if (bDecimal == null) bDecimal = (theFormat.indexOf(".") > -1);;
	}

	assignNumbers(event.keyCode);

	if ((event.keyCode < 44 || event.keyCode > 57 || event.keyCode == 47 || (!bNegatif && event.keyCode == 45 )|| (!bDecimal && ((event.keyCode == 44) || (event.keyCode == 46))))
		&& event.keyCode != 13 ) {

		window.event.keyCode = null;
		event.returnValue = false;
		return false;
	}

	event.returnValue = true;
}

/**
 * Vérifie à la volée les saisie de date
 */

function checkOnKeyPressToDate() {

	if (!internal_checkHelper( event.keyCode )) {
		event.returnValue = false;
		return false;
	}

	assignNumbers(event.keyCode);

	if ((event.keyCode < 48 || event.keyCode > 57) && event.keyCode != 13 ) {
		window.event.keyCode = null;
		event.returnValue = false;
	}

	event.returnValue = true;
}

/**
 * 	Vérifie à la volée les saisie de horaire
 * 	On autorise : "01234567899:"
 */

function checkOnKeyPressToTime() {

	if (!internal_checkHelper( event.keyCode )) {
		event.returnValue = false;
		return false;
	}

	assignNumbers(event.keyCode);

	if ((event.keyCode < 48 || event.keyCode > 58) && event.keyCode != 13 ) {
		window.event.keyCode = null;
		event.returnValue = false;
	}

	event.returnValue = true;
}

/** checkOnChange()
 *
 */

function internal_checkOnChangeIorga(theSelectObj) {

	// Si un événement OnChangeIorga est défini alors on exécute

	var onChangeIorga = theSelectObj.getAttribute("ONCHANGEIORGA");

	if (onChangeIorga != null) {

		try {
			return eval(onChangeIorga);
		}
		catch (e) {
			alert(e.message);
		}
	}
	return true;
}


function checkOnChange() {
	clearErrorIndicator(event.srcElement);
	return internal_checkOnChangeIorga( event.srcElement );
}


/** checkOnChangeDate()
 *
 */

function checkOnChangeDate( theDateObj ) {

	if (theDateObj == null ) theDateObj = event.srcElement;

	// On efface l'indicateur d'erreur
	clearErrorIndicator(theDateObj);

	if (theDateObj.value == "") return true;

	var dateFormat = theDateObj.getAttribute("DATEFIELD");

	if (dateFormat == "") {
		dateFormat = "JJMMAA";
	} else {
		dateFormat = dateFormat.toUpperCase();
	}

	var jour = 1;
	var mois = 7;
	var annee = "2000";
	var tailleAnnee = 2;

	if ( theDateObj.value.length != dateFormat.length ) {

		return setErrorIndicator(theDateObj, "Entered data ("+theDateObj.value+") is not a valid data. Please follow the input format \""+dateFormat+"\"." );
		//return setErrorIndicator(theDateObj, "La valeur saisie ("+theDateObj.value+") n'est pas une date valide." );

	}

	if (dateFormat == "JJMMAA") {

		jour = parseInt( theDateObj.value.substr(0, 2), 10 );
		mois = parseInt( theDateObj.value.substr(2, 2) - 1, 10 );
		annee = "20" + theDateObj.value.substr(4);

	} else if (dateFormat == "JJMMAAAA") {

		jour = parseInt( theDateObj.value.substr(0, 2), 10 );
		mois = parseInt( theDateObj.value.substr(2, 2) - 1, 10 );
		annee = theDateObj.value.substr(4);
		tailleAnnee = 4;

	} else if (dateFormat == "MMAAAA") {

		mois = parseInt( theDateObj.value.substr(0, 2) - 1, 10 );
		annee = theDateObj.value.substr(2);
		tailleAnnee = 4;

	} else if (dateFormat == "MMAA") {

		mois = parseInt( theDateObj.value.substr(0, 2) - 1, 10 );
		annee = "20" + theDateObj.value.substr(2);

	} else if (dateFormat == "MM") {

		mois = parseInt( theDateObj.value.substr(0, 2) - 1, 10 );
		tailleAnnee = 4;

	} else if (dateFormat == "AAAA") {

		annee = theDateObj.value;
		tailleAnnee = 4;

	} else if (dateFormat == "AA") {

		annee = "20" + theDateObj.value;
		tailleAnnee = 4;

	} else {
		alert("DEBUG: Format de date invalide \""+dateFormat+"\"");
		theDateObj.select();
		theDateObj.focus();
		return false;
	}

	if (tailleAnnee == 4 && annee.length != 4) {
		return setErrorIndicator(theDateObj, "The date should include the century (ex: 23071968, 07032001)." );

	} else if (tailleAnnee == 2 && annee.length != 4) {
		return setErrorIndicator(theDateObj, "The date should not include the century  (ex: 230702, 070301)." );
	}

	annee = parseInt(annee, 10);

	var	dDate = new Date( annee, mois, jour);

	if ( dDate.getMonth() != mois || dDate.getDate() != jour ) {

		//return setErrorIndicator(theDateObj, "La valeur saisie ("+theDateObj.value+") n'est pas une date valide. Veuillez suivre le format \""+dateFormat+"\"." );
		return setErrorIndicator(theDateObj, "Entered data ("+theDateObj.value+") is not a valid date." );

	}

	return internal_checkOnChangeIorga( theDateObj );
}

/** checkOnChangeTime()
 *
 */

function checkOnChangeTime( theTimeObj ) {

	if (theTimeObj == null ) theTimeObj = event.srcElement;

	// On efface l'indicateur d'erreur
	clearErrorIndicator(theTimeObj);

	if (theTimeObj.value == "") return true;

	var timeFormat = "HH:MI";

	if ( theTimeObj.value.length != 5 || theTimeObj.value.indexOf(":") != 2) {
		return setErrorIndicator(theTimeObj, "Entered data ("+theTimeObj.value+") is not a valid time. Please follow the input format \"HH:MI\" (ex: 20:15 or 05:32)." );
	}

	var heure = 0;
	var minute = 0;

	heure  = parseInt( theTimeObj.value.substr(0, 2), 10 );
	minute = parseInt( theTimeObj.value.substr(3, 2), 10 );

	if (heure < 0 || heure > 23) {
		return setErrorIndicator(theTimeObj, "Hour should be between 00 and 23." );

	}
	if (minute < 0 || minute > 59) {
		return setErrorIndicator(theTimeObj, "Minutes should be between 00 and 59." );
	}

	return internal_checkOnChangeIorga( theTimeObj );
}


/** checkPeriode()
 *
 *	Fonction de vérification d'une période. On considère que :
 *		- les date sont valides si renseignées
 *		- le format est "JJMMAA" ou "JJMMAAAA"
 *
 * 	@param	l'objet HTML représentant la date de début
 * 	@param	l'objet HTML représentant la date de fin
 * 	@return	false si la date de début est supérieure à la date de fin, true sinon.
 */

function checkPeriode( dateDebObj, dateFinObj) {

	// On efface l'indicateur d'erreur
	clearErrorIndicator( dateFinObj );

	if ( dateFinObj.value != "" && dateDebObj.value != "") {

		// Si les deux dates sont renseignées alors on teste

		var bufferDeb = dateDebObj.value.substring( 4) + dateDebObj.value.substring( 2, 4) + dateDebObj.value.substring( 0, 2);
		var bufferFin = dateFinObj.value.substring( 4) + dateFinObj.value.substring( 2, 4) + dateFinObj.value.substring( 0, 2);

		if ( bufferFin < bufferDeb ) {
			setErrorIndicator( dateFinObj, "If ending date is defined then it should be greater or equal than starting date ("+dateDebObj.value+")." );
			return false;
		}
	}
	return true;
}


/** checkPeriodeHoraire()
 *
 *	Fonction de vérification d'une période de temps (deux saisies horaires). On considère que :
 *		- les date sont valides si renseignées
 *		- le format est "HH:MI"
 *
 * 	@param	l'objet HTML représentant l'heure de début
 * 	@param	l'objet HTML représentant l'heure de fin
 * 	@return	false si l'heure  de début est supérieure à l'heure de fin, true sinon.
 */

function checkPeriodeHoraire( timeDebObj, timeFinObj) {

	// On efface l'indicateur d'erreur
	clearErrorIndicator( timeFinObj );

	if ( timeFinObj.value != "" && timeDebObj.value != "") {

		// Si les deux dates sont renseignées alors on teste

		var bufferDeb = parseInt( timeDebObj.value.substring( 0, 2) + timeDebObj.value.substring( 3), 10);
		var bufferFin = parseInt( timeFinObj.value.substring( 0, 2) + timeFinObj.value.substring( 3), 10);

		if ( bufferFin < bufferDeb ) {
			return setErrorIndicator( timeFinObj, "If ending time is defined then it should be greater or equal than starting time ("+timeDebObj.value+")." );
		}
	}
	return true;
}


/** checkOnChangeNumeric()
 *
 *	Cette méthode vérifie les saisies numériques
 */

function checkOnChangeNumeric( theNumericObj ) {

	if (theNumericObj == null ) theNumericObj = event.srcElement;

	// On efface l'indicateur d'erreur
	clearErrorIndicator(theNumericObj);

	if (theNumericObj.value == "") return true;

	var theFormat = theNumericObj.getAttribute("NUMERICFIELD");
	var theValue = theNumericObj.value;
	theValue = strReplaceAll( theValue, ",", "." );

	// Premièrement : est-ce une valeur numérique correcte ?

	try {
		theValue = 1 * theValue;
	}
	catch (e) {
		return setErrorIndicator(theNumericObj, "Entered data ("+theNumericObj.value+") is not a valid number." );
	}

	if (isNaN(theValue)) {
		return setErrorIndicator(theNumericObj, "Entered data ("+theNumericObj.value+") is not a valid number." );
	}

	theValue = String(theValue);

	if (theFormat != "testValeur") {

		/** On vérifie la conformité au Format */

		var maxDec = (theFormat.indexOf(".") == -1) ? 0 : (theFormat.length - theFormat.indexOf(".")) - 1;
		var maxInt = (theFormat.indexOf(".") == -1) ?
						((theFormat.indexOf("-") == -1) ?
								theFormat.length : theFormat.length - 1) :
						((theFormat.indexOf("-") == -1) ?
								theFormat.indexOf(".") : theFormat.indexOf(".") - theFormat.indexOf("-") -1 );

		var nbDec = (theValue.indexOf(".") == -1) ? 0 : (theValue.length - theValue.indexOf(".")) - 1;
		var nbInt = (theValue.indexOf(".") == -1) ?
						((theValue.indexOf("-") == -1) ?
								theValue.length : theValue.length - 1) :
						((theValue.indexOf("-") == -1) ?
								theValue.indexOf(".") : theValue.indexOf(".") - theValue.indexOf("-") - 1);

		if (theValue.indexOf("-") > -1 && theFormat.indexOf("-") == -1) {
			// Valeur négative
			return setErrorIndicator(theNumericObj, "Negative numbers ("+theNumericObj.value+	") are not accepted. Please follow the input format \""+theFormat+"\"." );
		}

		if (theValue.indexOf(".") > -1 && theFormat.indexOf(".") == -1) {
			// Valeur décimale
			return setErrorIndicator(theNumericObj, "Decimal numbers ("+theNumericObj.value+") are not accepted. Please follow the input format \""+theFormat+"\"." );
		}

		if ( nbInt > maxInt) {
			// taille zone entière
			return setErrorIndicator(theNumericObj, "Main part size is limited to "+maxInt+" digit(s). Please follow the input format \""+theFormat+"\"." );
		}

		if ( nbDec > maxDec) {
			// taille zone décimale
			return setErrorIndicator(theNumericObj, "Decimal part size is limited to "+maxDec+" digit(s). Please follow the input format \""+theFormat+"\"."  );
		}
	}

	if (theFormat.substring(0,1) == "0") {

		var cptInt = 0;

		for (cptInt = nbInt; cptInt < maxInt; cptInt++ ) theValue = "0"+theValue;
	} else {
		if (theValue.substring(0,1) == ".") theValue = "0"+theValue;
	}

	if (maxDec > 0 && nbDec > 0) {

		var cptDec = 0;

		for (cptDec = nbDec + 1; cptDec < maxDec; cptDec++ ) {
			if (theFormat.substring( theFormat.indexOf(".") + cptDec ,1) == "0" ) theValue += "0";
		}
	}

	theNumericObj.value = theValue;

	return internal_checkOnChangeIorga( theNumericObj );
}

/** checkOnChangeEmail()
 *
 * 	Cette méthode vérifie que le format de la valeur saisie est compatible
 *	avec le format des adresses email.
 *
 * 	@param	le champ contenant une valeur "adresse email"
 *
 * 	@return	true si le format correspond
 */

function checkOnChangeEmail( theEmailObj ) {

	if (theEmailObj == null ) theEmailObj = event.srcElement;

	// On efface l'indicateur d'erreur
	clearErrorIndicator(theEmailObj);

	if (theEmailObj.value == "") return true;

	if (theEmailObj.value.indexOf('@') < 2) {
		return setErrorIndicator(theEmailObj, "Entered value is not a valid email address. Please follow the input format \"xxxxxxxxxxx@xxxxxxxx.xx(x)\"."  );
	}

	if ((theEmailObj.value.charAt( theEmailObj.value.length - 4) != ".") && (theEmailObj.value.charAt( theEmailObj.value.length - 3) != ".")) {
		return setErrorIndicator(theEmailObj, "Entered value is not a valid email address. Please follow the input format \"xxxxxxxxxxx@xxxxxxxx.xx(x)\"."  );
	}

	return internal_checkOnChangeIorga( theEmailObj );
}

/** checkOnChangeSelectHelper()
 *
 */

function checkOnChangeSelectHelper( theSelHelperObj ) {

	if (theSelHelperObj == null ) theSelHelperObj = event.srcElement;

	// On efface l'indicateur d'erreur
	clearErrorIndicator(theSelHelperObj);

	var SelectObjName 	= theSelHelperObj.getAttribute("SELECTHELPERFIELD");
	var SelectObj = eval( "document.all."+SelectObjName );

	if (theSelHelperObj.value == "") {
		eval( "document.all."+SelectObjName+".options[0].selected = true");
		return internal_checkOnChangeIorga( SelectObj );
	}

	var nbOptions 		= 1 * eval( "document.all."+SelectObjName+".options.length");
	var bFound 			= false;
	var cptOption 		= 0;

	for (cptOption = 0; !bFound && cptOption < nbOptions; cptOption++) {

		if (theSelHelperObj.value == eval( "document.all."+SelectObjName+".options["+cptOption+"].value")) {

			eval( "document.all."+SelectObjName+".options["+cptOption+"].selected = true");
			bFound = true;
		}
	}

	if ( !bFound ) {

		return setErrorIndicator(theSelHelperObj, "Entered data (\""+theSelHelperObj.value+"\") can't be found in the linked Listbox." );
	}

	return internal_checkOnChangeIorga( SelectObj );
}

/** checkOnChangeSynchroHelper()
 *
 */

function checkOnChangeSynchroHelper( theSelectObj ) {

	if (theSelectObj == null ) theSelectObj = event.srcElement;

	if (onFocusSelectedIndex != theSelectObj.options.selectedIndex) {

		var theHelper = eval(theSelectObj.getAttribute("HELPERFIELD"));

		// L'option sélectionnée a changé

		clearErrorIndicator(theHelper);
		theHelper.value = theSelectObj.options[theSelectObj.options.selectedIndex].value;

		return internal_checkOnChangeIorga( theSelectObj );
	}

	return true;
}

/** afficherAssistant()
 *
 *	Cette methode affiche un assistant dans une fenêtre modale permettant
 *	à l'utilisateur d'effectuer un traitement (sélection).
 *	L'assistant doit retourner un TABLEAU (Array) ou bien null (si annulé)
 *
 *	@param	identifiant de la page appellante
 *	@param	identifiant de l'assistant
 *	@param	titre de la fenêtre
 *	@param	identifiant du champ contenant le paramètre (facultatif)
 * 	@param	taille minimale obligatoire du contenu du champ paramètre source (défaut : 1)
 *	@param	x paramètres désignant les cibles de stockage des élément du tableau retourné par l'assistant (déclatation dynamique)
 */

function afficherAssistant( sourcePage, helperUrl, titreAssistant, pWidth, pHeight, helperSourceField, minSize ) {

	if (sourcePage == null) alert("DEBUG : L'url de la page source est obligatoire.");
	if (helperUrl == null) alert("DEBUG : L'url de l'assistant est obligatoire.");
	if (titreAssistant == null) alert("DEBUG : Le titre de l'assistant est obligatoire.");
	if (pWidth == null) pWidth 		= "440";
	if (pHeight == null) pHeight 	= "326";

	var sourceParam = "";
	var nbreParam = 0;

	if (helperSourceField != null) {

		if (minSize == null) minSize = 1;

		if (helperSourceField.value.length < minSize ) {
			helperSourceField.select();
			helperSourceField.focus();
			return false;
		}
	}

	// Traitement des paramètres

	if (typeof(arguments[7]) == "number") {

		nbreParam = 2 * arguments[7];

		var sourceParam = "";
		var cptArgs = 0;

		while (cptArgs < nbreParam ) {

			sourceParam += "&"+arguments[8 + cptArgs]+"="+escape( arguments[ 9 + cptArgs ] );
			cptArgs += 2;
		}

		nbreParam++;	// On tient compte du champs Nbre de param

	} else {

		if (helperSourceField != null) {
			sourceParam = "&sourceparam="+escape(helperSourceField.value);
		}
	}

	var valeursReponse = showModalDialog( "GC?sourcepage="+sourcePage+"&targetpage=$RV_FRAME&titre="+escape(titreAssistant)+"&returnpage="+helperUrl+sourceParam,
								null,
								"dialogWidth:"+pWidth+"px; dialogHeight:"+pHeight+"px; center:yes; help:no; status=no; border:thick; resizable:no");

	if (valeursReponse != null) {

		if (valeursReponse.length  + 7 + nbreParam > arguments.length) {
			alert("DEBUG : Trop de valeurs retournées par l'assistant.");
			return false;
		}

		var cptArgs = 0;

		for (retName in valeursReponse ) {

			clearErrorIndicator(arguments[7 + cptArgs + nbreParam]);
			if (valeursReponse[retName] != null) arguments[7 + cptArgs + nbreParam].value = valeursReponse[retName];
			cptArgs++;
		}

		valeursReponse = null;
		window.returnValue = null;
	}
	else {
		if (helperSourceField != null) {
			helperSourceField.select();
			helperSourceField.focus();
		}
	}
	return false;
}

/** afficherDialogue()
 *
 *	Cette methode permet l'affichage des fenêtres modale (dialogue)
 *	L'utilisation d'une frame d'accueil générique autorise ainsi la navigation.
 *
 *	@param	identifiant de la page appellante
 *	@param	identifiant de l'assistant
 *	@param	titre de la fenêtre
 *	@param	largeur de la fenêtre (facultatif)
 *	@param	hauteur de la fenêtre (facultatif)
 *	@param	x paramètres désignant les cibles de stockage des élément du tableau retourné par l'assistant (déclatation dynamique)
 *
 *	@return valeur à retourner à la fonction appelante.
 */

function afficherDialogue( sourcePage, helperUrl, titreAssistant, pWidth, pHeight ) {

	if (sourcePage == null) alert("DEBUG : L'url de la page source est obligatoire.");
	if (helperUrl == null) alert("DEBUG : L'url de l'assistant est obligatoire.");
	if (titreAssistant == null) alert("DEBUG : Le titre de l'assistant est obligatoire.");
	if (pWidth == null) pWidth = "440";
	if (pHeight == null) pHeight = "326";

	if (((arguments.length - 5) % 2) != 0 ) alert("DEBUG : Nombre de paramètre incorrect.");

	var sourceParam = "";
	var cptArgs = 5;

	while (cptArgs < arguments.length ) {

		sourceParam += "&"+arguments[cptArgs]+"="+escape( arguments[cptArgs + 1] );
		cptArgs += 2;
	}

	var valeurReponse = showModalDialog( "GC?sourcepage="+sourcePage+"&targetpage=$DIALOG_FRAME&titre="+escape(titreAssistant)+"&returnpage="+helperUrl+sourceParam,
								null,
								"dialogWidth:"+pWidth+"px; dialogHeight:"+pHeight+"px; center:yes; help:no; status=no; border:thick; resizable:no");

//	window.returnValue = null;
	return valeurReponse;
}


/** linkEvents( theFormObj )
 *
 *	@param	le formulaire à traiter
 *
 */

function linkEvents( theFormObj ) {

	var objType;
	var theFormat;
	var typeFormat;
	var cptElement = 0;

	/** Traitement du bouton par défaut */
	var defaultBt = theFormObj.getAttribute("DEFAULTBUTTON");

	if (defaultBt != null) {
		// On créé en dynamique une fonction "Hôte"
		theFormObj.onkeypress = new Function("return internal_formKeyPressForAction( document.all."+defaultBt+" );")
	}

	/** Traitement des champs */

	for (cptElement = 0 ; cptElement < theFormObj.elements.length; cptElement++) {

	//	alert("Element["+cptElement+", "+theFormObj.elements[cptElement].type+"] = "+theFormObj.elements[cptElement].name);

		/** Activation de la mémorisation de la position du focus */
		theFormObj.elements[cptElement].onfocus = internal_memoOnFocus;

		objType = theFormObj.elements[cptElement].type;

		if ( objType == "text" ||
				objType == "select-one" ||
				objType == "select-multiple" ||
				objType == "checkbox" ||
				objType == "textarea" ||
				objType == "radio") {

			// Mémorisation du style original
			theFormObj.elements[cptElement].setAttribute("ORIGINALCLASSNAME", theFormObj.elements[cptElement].className);

			if (theFormObj.elements[cptElement].getAttribute("onchange") != null) {

				// On transforme le OnChange en attribut ONCHANGEIORGA
				theFormObj.elements[cptElement].setAttribute("ONCHANGEIORGA", theFormObj.elements[cptElement].getAttribute("onchange"));
			}

			if ( objType == "text" ) {

				/** Mapping de l'événement onKeyPress et onChange
				 *	sur les "text"
				 */

				if ((theFormat = theFormObj.elements[cptElement].getAttribute("UPPERCASEFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToUpperCase;
					typeFormat = "C";

				} else if ((theFormat = theFormObj.elements[cptElement].getAttribute("LOWERCASEFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToLowerCase;
					typeFormat = "C";

				} else if ((theFormat = theFormObj.elements[cptElement].getAttribute("EMAILFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToLowerCase;
					typeFormat = "M";

				} else if ((theFormat = theFormObj.elements[cptElement].getAttribute("NUMERICFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToNumeric;
					typeFormat = "N";

				} else if ((theFormat = theFormObj.elements[cptElement].getAttribute("DATEFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToDate;
					typeFormat = "D";

				} else if ((theFormat = theFormObj.elements[cptElement].getAttribute("TIMEFIELD")) != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToTime;
					typeFormat = "T";

				} else  {
					// Par défaut on linke sur le gestionnaire par défaut
					//var theFonction = theFormObj.elements[cptElement].getAttribute("ONKEYPRESSIORGA");

					//if (theFonction == null) {
						theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressDefault;
					//} else {
					//	theFormObj.elements[cptElement].onkeypress 	= new Function("{ if (checkOnKeyPressDefault()) { return "+theFonction+" }; return false;}");
					//}
				}

				// Select field Helper
				if (theFormObj.elements[cptElement].getAttribute("SELECTHELPERFIELD") != null) {
					typeFormat = "H";
				}

				if (theFormat != null) {

					if (typeFormat == "D") {
						theFormObj.elements[cptElement].onchange = checkOnChangeDate;
					}
					else if (typeFormat == "T") {
						theFormObj.elements[cptElement].onchange = checkOnChangeTime;
					}
					else if (typeFormat == "N") {
						theFormObj.elements[cptElement].onchange = checkOnChangeNumeric;
					}
					else if (typeFormat == "M") {
						theFormObj.elements[cptElement].onchange = checkOnChangeEmail;
					}
					else if (typeFormat == "H") {

						// Activation de la synchro helper -> select
						theFormObj.elements[cptElement].onchange = checkOnChangeSelectHelper;

						// Activation de la synchro select -> helper
						var theSelectObj = eval( "document.all."+theFormObj.elements[cptElement].getAttribute("SELECTHELPERFIELD"));
						theSelectObj.setAttribute("HELPERFIELD", "document.all."+theFormObj.elements[cptElement].name );
						theSelectObj.onblur = checkOnChangeSynchroHelper;

						/** On vérifie que la valeur du helper existe dans la liste associée */
						if (valueIsInSelectBox( theSelectObj, theFormObj.elements[cptElement].value) == -1) {
							setErrorIndicator(theFormObj.elements[cptElement], "La valeur saisie (\""+theFormObj.elements[cptElement].value+"\") ne correspond à aucune valeur de la liste associée.", true );
						}
					}
					else {
						/** Mapping de l'événement onKeyPress et onChange
						 *	sur les autres
						 */

						/** Mapping de l'événement onChange */
						theFormObj.elements[cptElement].onchange = checkOnChange;
					}
				}
				else {
					/** Mapping de l'événement onKeyPress et onChange
					 *	sur les autres
					 */

					/** Mapping de l'événement onChange */
					theFormObj.elements[cptElement].onchange = checkOnChange;
				}
			}
			else if ( objType == "textarea" ) {

				/** Mapping de l'événement onKeyPress et onChange
				 *	sur les "textarea"
				 */

				if (theFormObj.elements[cptElement].getAttribute("onkeypress") != null) {
					alert("L'ajout d'un gestionnaire onKeyPress sur une zone de texte ("+theFormObj.elements[cptElement].name+") n'est pas autorisé. Ce gestionnaire sera ignoré.");
				}

				if (theFormObj.elements[cptElement].getAttribute("UPPERCASEFIELD") != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToUpperCase;

				} else if (theFormObj.elements[cptElement].getAttribute("LOWERCASEFIELD") != null) {
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressToLowerCase;

				} else  {
					// Par défaut on linke sur le gestionnaire par défaut
					theFormObj.elements[cptElement].onkeypress 	= checkOnKeyPressDefault;
				}
			}
			else {
				/** Mapping de l'événement onKeyPress et onChange
				 *	sur les autres
				 */

				/** Mapping de l'événement onChange */
				theFormObj.elements[cptElement].onchange = checkOnChange;
			}
		}
	}
}

/** doOnLoadSystem()
 *
 *	Cette méthode effectue automatiquement un mapping de méthodes de contrôle
 *	sur tous les champs des formulaires de la page
 *
 */

//function internal_doSubmit() {
//	document.body.style.cursor="wait";
//	return true;
//}

function doOnLoadSystem() {

	// Support de la zone d'affichage des erreurs clientes

	var zoneID = document.body.getAttribute("ERRORDISPLAYZONE");

	if (zoneID != null) {
		// On créé en dynamique une fonction "Hôte"
		showErrorZoneID = eval("document.all."+zoneID);
		showErrorZoneID.className = KOStyleClassName;
	}

	// Link des événements systèmes Iorga

	var cptForm = 0;

	for (cptForm = 0; cptForm < document.forms.length; cptForm++ ) {
		linkEvents( document.forms[cptForm]);

//		document.forms[cptForm].onsubmit = internal_doSubmit;
	}

	try {
		doOnLoad();
	} catch (e) {}
}

/** showApplicationError()
 *
 *	Fonction par défaut d'affichage des erreurs de saisie détectées entre autres par
 *	par le traitement coté serveur (servlet)
 *	Cette fonction peut être redéfinie dans le source de la page afin de gérér autrement
 *	l'affichage de ce type d'erreur.
 *
 *	@param	champ de formulaire en erreur
 *	@param	texte de l'erreur
 *	@param	position de l'erreur dans la liste
 *	@param	nombre total d'erreurs retournée
 */

function showApplicationError( pField, pErrTexte, numErr, nbreErr ) {

	// On force le mode furtif
	eval("setErrorIndicator(document.all."+pField+", \""+pErrTexte+" ("+numErr+"/"+nbreErr+")\", true)" );

	if (numErr == 1) {
		//eval("document.all."+pField+".select();" );
		eval("document.all."+pField+".focus();" );
	}

	if (numErr == nbreErr) {

		// Message d'avertissement général

		if (nbreErr == 1) {
			alert("You should correct the error before to be allowed to continue.");
		} else {
			alert("You should correct the "+nbreErr+" errors before to be allowed to continue.");
		}
	}

	return;
}

/** initSelect()
 *
 *	Fonction qui initialise une liste déroulante par rapport
 *	au contenu du helper dynamique.
 *
 * 	@param	Object Helper
 * 	@param	Object liste déroulante
 */
function initSelect( ObjHelper, ObjSelect ) {

	var elementSelect;
	for (elementSelect=0; elementSelect < ObjSelect.options.length; elementSelect++) {
		if (ObjSelect.options[elementSelect].value == ObjHelper.value) {
			ObjSelect.options[elementSelect].selected = true;
			break;
		}
	}

}