//#14.00Aa WDObjetBase.JS
//VersionVI: 30F140029t
// Le seul support technique disponible pour cette librairie est
// accessible a travers le service "Assistance Directe".

// Classe utilitaire de gestion d'un tableau de champ indice par nom
function WDTableauChamps ()
{
	// Tableau fils qui contient les champs
	// La classe n'herite pas de Array (c'est +/- inutile en plus), car sinon cela interdirai toute variable locale
	this.m_tabChamps = [];
}

// Nombre de champ
WDTableauChamps.prototype.nGetNbChamps = function()
{
	return this.m_tabChamps.length;
};

// Declare un champ
WDTableauChamps.prototype.DeclareChamp = function(oChamp)
{
	this.m_tabChamps[oChamp.m_sAliasChamp] = oChamp;
};

// Recupere un champ
WDTableauChamps.prototype.oGetChamp = function(sChamp)
{
	return this.m_tabChamps[sChamp];
};

// Appele une methode sur tous les camps
WDTableauChamps.prototype.AppelMethode = function(sFonction, tabParam, oExclus)
{
	for (var sChamp in this.m_tabChamps)
	{
		// Recupere le champ et teste sa validite
		var oChamp = this.m_tabChamps[sChamp];
		if (oChamp && (oChamp != oExclus))
		{
			// Applique alors la methode sur le champ
			oChamp[sFonction].apply(oChamp, tabParam);
		}
	}
};

// Appele une methode sur un champ dont on connait le nom
// tabParam : tableau des parametres
WDTableauChamps.prototype.AppelMethodeChamp = function(sAlias, sFonction, tabParam)
{
	var oChamp = this.oGetChamp(sAlias);
	if (oChamp)
	{
		oChamp[sFonction].apply(oChamp, tabParam);
	}
};

// Classe de base de manipulation des champs de WebDev
// - Gestion de l'appartenace a :
//	- Une ZR
//	- Un onglet
// - Gestion des evenements AJAX (affectation etc)
function WDChamp(sAliasChamp, sAliasZR, sAliasAttribut)
{
	// Si on est pas dans l'init d'un protoype
	if (sAliasChamp)
	{
		// L'alias du champ
		this.m_sAliasChamp = sAliasChamp;
		// La ZR eventuelle qui contient le champ si la propriete ..Valeur est liee a un attribut (sAliasChamp est alors l'alias de cet attribut)
		if (sAliasZR)
		{
			this.m_sAliasZR = sAliasZR;
			this.m_sAliasAttribut = sAliasAttribut;
		}

		// Tableau des PCodes du champ
		this.m_tabPCodes = [];

		// Le champ est actif
//		this.m_nVisible = true;
		this.m_eEtat = this.ms_eEtatActif;
	}
}

// Tableau global des champs JS de la page
WDChamp.prototype.ms_tabChamps = new WDTableauChamps();
// Tableau global des ZRs/Tables de la page (pour pouvoir les manipulers des les inits des champs
WDChamp.prototype.ms_tabTablesZRs = new WDTableauChamps();
// Numero des PCodes navigateurs
WDChamp.prototype.ms_nEventNavBlur = 10;
WDChamp.prototype.ms_nEventNavChange = 11;
WDChamp.prototype.ms_nEventNavFocus = 12;
WDChamp.prototype.ms_nEventNavSelectLigne = 20;
WDChamp.prototype.ms_nEventNavAffichageMois = 28;
WDChamp.prototype.ms_nEventNavSelectionJour = 29;
// Fonction vide pour la gestion des PCodes
WDChamp.prototype.m_pfVide = function() { return true; }
// Etats des champs.AppelMethode Les valeurs mappent sur les valeurs WL meme si visible n'est pas utilise
WDChamp.prototype.ms_eEtatActif = 0;
WDChamp.prototype.ms_eEtatLectureSeule = 1;
WDChamp.prototype.ms_eEtatGrise = 4;

// Initialisation
WDChamp.prototype.Init = function()
{
	// Si c'est l'init du premier champ
	if (WDChamp.prototype.ms_tabChamps.nGetNbChamps() == 0)
	{
		this.__InitInitiale();
	}

	// Si le champ est dans une ZR : notifie l'objet ZR de sa presence
	// Note : On ne peut pas faire cette declaration dans le constructeur car l'existence de l'objet de la ZR n'est pas garanti
	// En effet l'ordre actuel de creation des objets est : fils puis parent
	// Ce qui signifie que la liste comlete n'est pas complete avant la fin de tous les init. Sauf que l'init de la ZR est
	// alors pares celui de tous ces fils donc on peut considerer qu'il existe
	if (this.bGestionZR())
	{
		WDChamp.prototype.ms_tabTablesZRs.AppelMethodeChamp(this.m_sAliasZR, "DeclareChampFils", [this]);
	}

	// Se memorise comme champ dans le tableau global
	// Fait dans l'init et pas dans la construction, pour ne pas ajouter un champ invalide
	WDChamp.prototype.ms_tabChamps.DeclareChamp(this);
};

// Methode d'initialisation generale de la classe
// Appelle lors de l'init du PREMIER champ
WDChamp.prototype.__InitInitiale = function()
{
	// Enregistre l'evenement onresize sur la fenetre
	var fOnResize;
	if (bIE)
	{
		fOnResize = function() { AppelMethode(WDChamp.prototype.ms_sOnResize, [event], undefined) };
	}
	else
	{
		fOnResize = function(oEvent) { AppelMethode(WDChamp.prototype.ms_sOnResize, [oEvent], undefined) };
	}
	HookOnXXX(window, 'onresize', 'resize', fOnResize);
};

// Methode STATIQUE : Recupere l'objet attache a un champ
function oGetObjetChamp(sAlias)
{
	return WDChamp.prototype.ms_tabChamps.oGetChamp(sAlias);
};

// Methode STATIQUE : Appele une methode sur tout les champs sauf le champ passe en parametre
// Il est possible de ne pas passer le parametre
// tabParam : tableau des parametres
function AppelMethode(sFonction, tabParam, oExclus)
{
	WDChamp.prototype.ms_tabChamps.AppelMethode(sFonction, tabParam, oExclus);
};

// Methode STATIQUE : Appele une methode sur un champ dont on connait le nom
// tabParam : tableau des parametres
function AppelMethodeChamp(sAlias, sFonction, tabParam)
{
	WDChamp.prototype.ms_tabChamps.AppelMethodeChamp(sAlias, sFonction, tabParam);
}

// Appele une methode sur tout les champs sauf sur le champ courant
// tabParam : tableau des parametres
WDChamp.prototype.AppelMethodeAutres = function(sFonction, tabParam)
{
	AppelMethode(sFonction, tabParam, this);
};

//////////////////////////////////////////////////////////////////////////
// Gestion des PCodes

// Declare un PCode navigateur au champ
WDChamp.prototype.DeclarePCode = function(ePCodeNav, pfFonction)
{
	this.m_tabPCodes[ePCodeNav] = pfFonction;
};

// Recupere un PCode navigateur du champ
// Cette fonction n'appele pas le PCode : il n'est pas possible de transformer simplement les parametres variables et en supprimant un
// Mais cette fonction retourne une fonction vide qui permet de ne rien faire planter
WDChamp.prototype.RecuperePCode = function(ePCodeNav)
{
	var pfFonction = this.m_tabPCodes[ePCodeNav];
	if (pfFonction)
	{
		return pfFonction;
	}
	return this.m_pfVide;
};

//////////////////////////////////////////////////////////////////////////
// Etat du champ

// Etats des champs. Les valeurs mappent sur les valeurs WL meme si visible n'est pas utilise
WDChamp.prototype.SetEtat = function(eEtat)
{
	this.m_eEtat = eEtat;
};
WDChamp.prototype.eGetEtat = function()
{
	return this.m_eEtat;
};

// Methode predefinies nommee
// - Tous les champs : affectation du contenu HTML pour l'AJAX
WDChamp.prototype.PreAffecteHTML = function PreAffecteHTML(bDepuisAJAX) { };
WDChamp.prototype.ms_sPreAffecteHTML = "PreAffecteHTML";
WDChamp.prototype.PostAffecteHTML = function PostAffecteHTML(bDepuisAJAX) { };
WDChamp.prototype.ms_sPostAffecteHTML = "PostAffecteHTML";
// - Tous les champs : Notifie le champ le conteneur xxx est affiche via un .display = "block"
WDChamp.prototype.OnDisplay = function OnDisplay(oElementRacine) { };
WDChamp.prototype.ms_sOnDisplay = "OnDisplay";
// - Tous les champs : Notifie le champ que la fenetre est redimentionnee
WDChamp.prototype.OnResize = function OnResize(oEvent) {};
WDChamp.prototype.ms_sOnResize = "OnResize";
// - Tous les champs : affectation de la valeur
WDChamp.prototype.SetValeur = function SetValeur(sValeur, oChamp) { };
WDChamp.prototype.ms_sSetValeur = "SetValeur";
// - Champs de saisie : affectation de l'indication
WDChamp.prototype.SetIndication = function SetIndication(sNouvelleIndication) { };
WDChamp.prototype.ms_sSetIndication = "SetIndication";
// - Champ graphe : affectation des parametres du graphe
WDChamp.prototype.DeduitParam = function DeduitParam(sParamGraphe) { };
WDChamp.prototype.ms_sDeduitParam = "DeduitParam";
// - Champ table : rafraichissement du contenu
WDChamp.prototype.Refresh = function Refresh(nReset, nNouveauDebut, sCleNouveauDebut) { };
WDChamp.prototype.ms_sRefresh = "Refresh";
// - Champ avec "barre" (graphe/saisie riche)
WDChamp.prototype.MasqueBarre = function MasqueBarre() { };
WDChamp.prototype.ms_sMasqueBarre = "MasqueBarre";

// Methode appele directement
// - Champ dans une ZR : notifie le champ de l'affichage/suppression de la ligne
WDChamp.prototype.OnLigneZRAffiche = function OnLigneZRAffiche(nLigneAbsolueBase1, bSelectionne) { };
WDChamp.prototype.ms_sOnLigneZRAffiche = "OnLigneZRAffiche";
WDChamp.prototype.OnLigneZRMasque = function OnLigneZRMasque(nLigneAbsolueBase1, bSelectionne, oEvent) { };
WDChamp.prototype.ms_sOnLigneZRMasque = "OnLigneZRMasque";

//////////////////////////////////////////////////////////////////////////
// Gestion des ZRs

// Indique si on est dans une ZR
WDChamp.prototype.bGestionZR = function()
{
	return ((this.m_sAliasZR) ? true : false);
};
// Indique si on est dans une ZR AJAX et si c'est le cas retourne l'objet de la ZR (sinon retourne undefined)
WDChamp.prototype.oGetZRAjax = function()
{
	return (this.bGestionZR() ? WDChamp.prototype.ms_tabTablesZRs.oGetChamp(this.m_sAliasZR) : undefined);
};

// Retourne le premier element d'une ZR (le champ DOIT etre dans une ZR)
WDChamp.prototype.nGetZRValeur = function()
{
	return parseInt(document.getElementsByName(this.m_sAliasZR)[0].value, 10);
};
WDChamp.prototype.SetZRValeur = function(oEvent, nLigneAbsolueBase1)
{
	// Si on est dans une ZR AJAX, notifie le champ
	var oZRAjax = this.oGetZRAjax();
	if (oZRAjax)
	{
		oZRAjax.OnSelectLigneZR(nLigneAbsolueBase1 - oZRAjax.m_nDebut - 1, oEvent);
	}
	else
	{
		// Sinon ecrit directement dans le champ formulaire
		document.getElementsByName(this.m_sAliasZR)[0].value = nLigneAbsolueBase1;
	}
};
WDChamp.prototype.nGetZRDebut = function()
{
	return parseInt(document.getElementsByName(this.m_sAliasZR + "_DEB")[0].value, 10);
};
WDChamp.prototype.nGetZROccurrence = function()
{
	return parseInt(document.getElementsByName("_" + this.m_sAliasZR + "_OCC")[0].value, 10);
};

//////////////////////////////////////////////////////////////////////////
// Gestion des champs

// Retourne le nom d'un objet en fonction de son suffixe et du nom du champ
WDChamp.prototype.sGetNomElement = function(sSuffixe)
{
	return this.m_sAliasChamp + sSuffixe;
};
// Retourne un objet en fonction de son suffixe et du nom du champ
WDChamp.prototype.oGetElementById = function(oDocument, sSuffixe)
{
	return oDocument.getElementById(this.sGetNomElement(sSuffixe));
};
WDChamp.prototype.oGetElementByName = function(oElement, sSuffixe)
{
	return oElement.getElementsByName(this.sGetNomElement(sSuffixe))[0];
};

//////////////////////////////////////////////////////////////////////////
// Gestion des champs dans les ZRs

// Retourne le nom d'un objet en fonction de son suffixe, du nom du champ et de la presence d'une ZR
WDChamp.prototype.sGetNomElementZR = function(sSuffixe)
{
	return this.sGetNomElementZRCalc(this.bGestionZR(), sSuffixe);
};
// Retourne le nom d'un objet en fonction de son suffixe, du nom du champ et de la presence d'une ZR selon le parametre
WDChamp.prototype.sGetNomElementZRCalc = function(bDansZR, sSuffixe)
{
	// Si on est dans une ZR
	if (bDansZR)
	{
		// Retourne _INDICEZR_ALIASCHAMP + suffixe
		return this.sGetNomElementZRIndice(this.nGetZRValeur(), sSuffixe);
	}
	else
	{
		// Pas dans une ZR : methode normale
		return this.sGetNomElement(sSuffixe);
	}
};

// Retourne le nom d'un objet en fonction de son suffixe, du nom du champ et de son indice dans la ZR
WDChamp.prototype.sGetNomElementZRIndice = function(nIndice, sSuffixe)
{
	// Retourne _INDICEZR_ALIASCHAMP + suffixe
	// Dans les ZR fichier avec rebond il faut tenir compte de this.nGetZRDebut() ?
//	return "_" + (nIndice + this.nGetZRDebut() - 1) + "_" + this.m_sAliasAttribut + sSuffixe;
	return "_" + nIndice + "_" + this.m_sAliasAttribut + sSuffixe;
};

// Retourne un objet en fonction de son suffixe, du nom du champ et de la presence d'une ZR
WDChamp.prototype.oGetElementByIdZR = function(oDocument, sSuffixe)
{
	return this.oGetElementByIdZRCalc(this.bGestionZR(), oDocument, sSuffixe);
};
WDChamp.prototype.oGetElementByNameZR = function(oElement, sSuffixe)
{
	return this.oGetElementByNameZRCalc(this.bGestionZR(), oElement, sSuffixe);
};

// Retourne un objet en fonction de son suffixe, du nom du champ et de la presence d'une ZR selon le parametre
WDChamp.prototype.oGetElementByIdZRCalc = function(bDansZR, oDocument, sSuffixe)
{
	return oDocument.getElementById(this.sGetNomElementZRCalc(bDansZR, sSuffixe));
}
WDChamp.prototype.oGetElementByNameZRCalc = function(bDansZR, oElement, sSuffixe)
{
	return oElement.getElementsByName(this.sGetNomElementZRCalc(bDansZR, sSuffixe))[0];
};

// Retourne un objet en fonction de son suffixe, du nom du champ et de son indice dans la ZR
WDChamp.prototype.oGetElementByIdZRIndice = function(oDocument, nIndice, sSuffixe)
{
	return oDocument.getElementById(this.sGetNomElementZRIndice(nIndice, sSuffixe));
}
WDChamp.prototype.oGetElementByNameZRIndice = function(oElement, nIndice, sSuffixe)
{
	return oElement.getElementsByName(this.sGetNomElementZRIndice(nIndice, sSuffixe))[0];
};