//======================================================================
// Libreria contenente la classe AJAXHandler per la realizzazione di varie tipologie di menu. La classe AJAXHandler
// pu\u00F2 essere utilizzate per effettuare richieste client to server via HTTP asincrone o sincrone.
//
// Avvertenza:
// si esortano gli utilizzatori a non effettuare modifiche non autorizzate su questa libreria. Tali modifiche verrebbero
// perse in caso di aggiornamento ed inoltre potrebbero causare malfunzionamenti nelle funzioni che ne fanno uso.
//
// Prerequisiti:
// - Libreria QJS Basic 4.0 o superiore
// - Libreria QJS AJAX 4.0 o superiore
//
// Versioni:
// - 1.0			Prima versione ufficialmente rilasciata. Utilizzata per HSE.
// - 2.0			Eliminata la classe QWidgetHandler e sostituita con QWidgetContainer e QWidget.
//
// Propriet\u00E0:	Quattroemme S.p.A.
// Autore:		Francesco Diamanti
//======================================================================

//======================================================================
// Variabili e costanti globali
//======================================================================
var QWIDGET_ACCESS_DENIED = "<br><br><b>L'utente non \u00E8 autorizzato ad accedere a quest'area</b><br><br><br>"
var QWIDGET_DEFAULT_TARGET = "Contenuti"
var QWIDGET_ID_SEP = "_"
var QWIDGET_MENU_AGENT_NAME = "QWidgetJSONMenu"

//======================================================================
// Class QWidget
//======================================================================
function QWidget(widgetNodeX) {

	//Gestisce una singola QWidget.
	//Parametri:
	//- widgetNode			Nodo del documento o suo id rappresentante la QWidget
	
	var widgetBody
	var widgetHead
	var widgetNode
		
	//------------------------------------------------------------------------------------------------------------------------
	// Metodi pubblici
	//------------------------------------------------------------------------------------------------------------------------
	this.loadContent = M_loadContent						//Carica il contenuto di una widget di tipo AJAX o Menu
	this.JSInitialize = M_JSInitialize							//Esegue la funzione JS di inizializzazione associata alla widget
	
	//Inizializzazione
	initialize()
	
	//------------------------------------------------------------------------------------------------------------------------
	// Definizione dei metodi pubblici
	//------------------------------------------------------------------------------------------------------------------------
	function M_JSInitialize() {
		//Esegue la funzione JS di inizializzazione associata alla widget
		try {
			if (widgetBody) {
				var initJS = widgetBody.attributes["initJS"]
				if (initJS && initJS.value != "") eval(initJS.value)
			}
		}
		catch(e) {QException(e, "QWidget.JSInitialize")}
	}
				
	//------------------------------------------------------------------------------------------------------------------------
	function M_loadContent() {
		//Carica il contenuto di una widget di tipo AJAX o Menu
		try {
			if (widgetBody) {
				var ajaxURL = widgetBody.attributes["ajaxURL"]
				if (ajaxURL && ajaxURL.value != "") {
					//Widget di tipo AJAX
					var AJAX = new AJAXHandler()
					AJAX.sendRequest(ajaxURL.value, createAJAXContent)
				}
				else {
					var menuName = widgetBody.attributes["menuName"]
					if (menuName && menuName.value) {
						//Widget di tipo menu
						var AJAX = new AJAXHandler()
						var URL = QCurPath + "/" + QWIDGET_MENU_AGENT_NAME
						AJAX.addParameter("menuName", menuName.value)
						AJAX.sendRequest(URL, createMenuContent, "json")
					}
				}
			}
		}
		catch(e) {QException(e, "QWidget.loadContent")}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	// Metodi privati
	//------------------------------------------------------------------------------------------------------------------------
	function initialize() {
		//Inizializzazione dell'oggetto
		try {
			//Istanzia il nodo della widget
			widgetNode = (typeof(widgetNodeX) == "string")? document.getElementById(widgetNodeX) : widgetNodeX
			//Istanzia i nodi del corpo e dell'intestazione della widget
			var child = widgetNode.firstChild
			while (child) {
				if (child.type) {
					switch (child.type) {
						case "QWidgetBody":
							widgetBody = child
							break
						case "QWidgetHeader":
							widgetHead = child
							break
					}
				}
				child = child.nextSibling
			}
		}
		catch(e) {QException(e, "QWidget.initialize")}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	function createAJAXContent(AJAX) {
		//Carica il contenuto del body della widget di tipo AJAX
		try {
			if (AJAX) {
				widgetBody.innerHTML = AJAX
				//Esegue lo script di inizializzazione
				M_JSInitialize()
			}
		}
		catch(e) {QException(e, "QWidget.createAJAXContent")}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	function createMenuContent(JSON) {
		//Carica il contenuto del body della widget di tipo Menu
		try {
			var menu
			if (JSON) {
				switch (JSON.menu[0].menuType) {
					case "DD":
						//Menu drop down
						widgetBody.style.overflow = "visible"
						menu = new QDropDownMenu()
						menu.JSONBuilder(JSON)
						menu.create(widgetBody)
						menu.show()
						break
					case "C":
						//Menu a colonna
						menu = new QColumnMennu(widgetBody)
						menu.JSONBuilder(JSON)
						break
				}
			}
		}
		catch(e) {QException(e, "QWidget.createMenuContent")}
	}
}

//======================================================================
// Class QWidgetContainer
//======================================================================
function QWidgetContainer(widgetAreaX) {

	//Gestisce un QWidgetContainer
	//Parametri:
	//- widgetAreaX				Nodo della pagina o suo id nel quale creare il QWidgetContainer
	
	var widgetArea
	
	var VIEW_NAME = "QCompiledKey"
	
	//------------------------------------------------------------------------------------------------------------------------
	// Metodi pubblici
	//------------------------------------------------------------------------------------------------------------------------
	this.loadContainer = M_loadContainer
	
	//Inizializzazione
	initialize()
	
	//------------------------------------------------------------------------------------------------------------------------
	// Definizione dei metodi pubblici
	//------------------------------------------------------------------------------------------------------------------------
	function M_loadContainer(title) {
		//Carica il codice HTML del QWidgetContainer nel nodo della pagina indicato nella variabile globale widgetArea
		//Parametri:
		//- title				Titolo del QWidgetContainer da caricare.
		try {
			var AJAX = new AJAXHandler()
			//Compone il percorso ed esegue la richiesta AJAX
			var URL = QCurPath + "/" + VIEW_NAME + "/" + title + "?OpenDocument"
			AJAX.sendRequest(URL, createContainer)
		}
		catch(e) {QException(e, "method QWidgetContainer.loadContainer")}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	// Metodi privati
	//------------------------------------------------------------------------------------------------------------------------
	function initialize() {
		//Inizializzazione dell'oggetto
		try {
			//Istanzia il nodo della pagina che dovr\u00E0 contenere il codice HTML del QWidgetContainer
			widgetArea = (typeof(widgetAreaX) == "string")? document.getElementById(widgetAreaX) : widgetAreaX
		}
		catch(e) {QException(e, "QWidgetContainer.initialize")}
	}
	
	//------------------------------------------------------------------------------------------------------------------------
	function createContainer(AJAX) {
		//A seguito della richiesta AJAX, crea il codice HTML del QWidgetContainer nella WidgetArea
		try {
			if (widgetArea) {
				//Verifica la bonta della risposta alla richiesta AJAX. Deve cominciare con un tag div.
				if (AJAX.substr(0, 4).toLowerCase() == "<div") {
					widgetArea.innerHTML = AJAX
					
					//Carica i contenuti delle QWidget di tipo AJAX ed invoca le funzioni JS eventualmente associate alle altre
					var bodies = QNodeGetByAttribute(widgetArea, "type", "QWidgetBody")
		 			for (var i = 0; i < bodies.length; i++) {
		 				//Verifica se si tratti di una widget AJAX o Menu
		 				var ajaxURL = bodies[i].attributes["ajaxURL"]			
		 				var menuName = bodies[i].attributes["menuName"]
		 				if (ajaxURL || menuName) {
			 				//Caricamento dei contenuti di widget AJAX o Menu. Eseguir\u00E0 anche l'eventuale inizializzazione js.
			 				var widget = new QWidget(bodies[i].parentNode)
			 				widget.loadContent()
		 				}
		 				else {
			 				//Inizializzazione JS per tutte le altre widget, dove prevista
			 				var initJS = bodies[i].attributes["initJS"]
			 				if (initJS && initJS.value != "") eval(initJS.value)
						}
		 			}
				}
				else widgetArea.innerHTML = QWIDGET_ACCESS_DENIED
			}
		}
		catch(e) {QException(e, "method QWidgetContainer.createContainer")}
	}
}

//=====================================================================
// QWidget functions
//=====================================================================
function QWidgetAlternateContainer(widgetName, pShow) {
	//Dato un container di riferimento, gestisce la visibilit\u00E0 di due container tra loro alternativi.
	//Parametri:
	//- widgetName		Nome del container di riferimento o di una widget o container al suo interno.
	//- pShow				Se true (default) il container di riferimento verr\u00E0 reso visibile mentre quello alternativo
	//						verr\u00E0 nascosto. Se false assicura il contrario.
	try {
		var show = (pShow == undefined)? true : pShow
		var node = QGetWidgetByName(widgetName)
		var container
		var altContainer

		if (node) {
			//Verifica la tipologia di id indicata, widget o widget container, e determina il container.
			
			// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto sostituisce quella commentata
			// al di sotto di essa perch\u00E9 quest'ultima non \u00E8 cross-browser
			if (node.getAttribute("type").toUpperCase() == "QWIDGETCONTAINER") container = node
	//		if (node.type.toUpperCase() == "QWIDGETCONTAINER") container = node
			else container = node.parentNode
		}
		if (container) {
			//Cicla dal container corrente a tutti i parent alla ricerca di un container avente attributo AltContainer
			while (container.nodeName.toLowerCase() != "div") {
			
				// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto sostituisce quella commentata
				// al di sotto di essa perch\u00E9 quest'ultima non \u00E8 cross-browser
				if (container.getAttribute("altcontainer") != undefined) break
		//		if (container.AltContainer != undefined) break
				container = container.parentNode
			}
			//Verifica che il container corrente sia provvisto dell'attributo AltContainer
			
			// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto sostituisce quella commentata
			// al di sotto di essa perch\u00E9 quest'ultima non \u00E8 cross-browser
			if (container.getAttribute("altcontainer") != undefined) {
		//	if (container.AltContainer != undefined) {
			
				// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto sostituisce quella commentata
				// al di sotto di essa perch\u00E9 quest'ultima non \u00E8 cross-browser
				altContainer = QGetWidgetByName(container.getAttribute("altcontainer"))
		//		altContainer = QGetWidgetByName(container.AltContainer)
				if (altContainer) {
					if (show) {
						container.style.display = "block"
						altContainer.style.display = "none"
					}
					else {
						container.style.display = "none"
						altContainer.style.display = "block"
					}
				}
			}
		}	
	}
	catch(e) {QException(e, "QWidgetAlternateContainer")}
}

//=====================================================================
function QGetWidgetByAttribute(attributeName, attributeValue, widgetType) {
	try {
		var allDiv = document.getElementsByTagName("div")
		var array = new Array()
		var cont = -1
		//Cicla su tutti gli elementi div del documento alla ricerca di quello con attributo e tjpo dato
		for (var index = 0; index < allDiv.length; index++) {
			//Se indicato il tipo di widget verifica che quella corrente sia tale.
			if (widgetType == undefined || allDiv[index].type == widgetType) {
				if (allDiv[index].attributes[attributeName]) {
					if (allDiv[index].attributes[attributeName].value.toUpperCase() == attributeValue.toUpperCase()) {
						cont++
						array[cont] = allDiv[index]
					}
				}
			}
		}
		return array
	}
	catch(e) {QException(e, "QGetWidgetByAttribute")}
}

//=====================================================================
function QGetWidgetWithAttribute(attributeName, widgetType) {
	try {
		var allDiv = document.getElementsByTagName("div")
		var array = new Array()
		var cont = -1
		//Cicla su tutti gli elementi div del documento alla ricerca di quello con attributo e tjpo dato
		for (var index = 0; index < allDiv.length; index++) {
			//Se indicato il tipo di widget verifica che quella corrente sia tale.
			if (widgetType == undefined || allDiv[index].type == widgetType) {
				if (allDiv[index].attributes[attributeName]) {
					cont++
					array[cont] = allDiv[index]
				}
			}
		}
		return array
	}
	catch(e) {QException(e, "QGetWidgetWithAttribute")}
}

//=====================================================================
function QGetWidgetById(id) {
	//Restituisce una widget avente id dato
	try {
		var widget = document.getElementById(id)
		var back
		if (widget) {
			if (widget.attributes["type"]) {
				if (widget.attributes["type"].value.substr(0, 6) == "QWidget") back = widget
			}
		}
		return back
	}
	catch(e) {QException(e, "QGetWidgetById")}
}

//=====================================================================
function QGetWidgetByName(name) {
	//Rrestituisce una widget in base all'attributo name indicato. Assume che tale attributo sia univoco sulla pagina
	try {
		var widgets = QGetWidgetByAttribute("name", name)
		if (widgets.length > 0) return widgets[0]
	}
	catch(e) {QException(e, "QGetWidgetByName")}
}

//=====================================================================
function QWidgetClose(widgetId) {
	try {
		var widget = QGetWidgetById(widgetId)
		if (widget) {
			var parent = widget.parentNode
			if (parent) parent.removeChild(widget)
		}
	}
	catch(e) {QException(e, "QWidgetClose")}
}

//=====================================================================
function QWidgetMagnify(widgetId) {
	try {
		var body = QGetWidgetById(widgetId + QWIDGET_ID_SEP + "body")
		var content = body.firstChild
		if (content) {
			if (content.nodeName.toLowerCase() == "iframe") {
				var src = content.attributes["src"].value					
			}
		}
	}
	catch(e) {QException(e, "QWidgetMagnify")}
}

//=====================================================================
function QWidgetSetTitle(pWidget, title) {
	try {
		var widget = (typeof(pWidget) == "string")? document.getElementById(pWidget) : pWidget
		if (widget) {
 			var id = widget.id + QWIDGET_ID_SEP + "header" + QWIDGET_ID_SEP + "Title"
 			var titleObj = document.getElementById(id)
 			if (titleObj) titleObj.innerHTML = title
		}
	}	
	catch(e) {QException(e, "QWidgetSetTitle")}
}

//=====================================================================
function QWidgetURLOpen(pURL, pTitle, pHeight, pTarget) {
	//Funzione di apertura di url da utilizzare in un contesto widget.
	//Parametri:
	//- pURL			URL da aprire
	//- pTitle			Titolo della widget nella quale l'url verr\u00E0 aperto
	//- pHeight		Altezza che la widget dovr\u00E0 assumere. Il default prevede tutto lo spazio disponibile.
	//- pTarget		Target di apertura. Assume i seguenti valori:
	//					"_blank" per aprire in una nuova finestra
	//					"_self"	per aprire nella finestra corrente
	//					id di una widget per aprire l'url in una data widget
	//					default = widget contenuti
	try {
		var title = (pTitle == undefined)? "" : "" + pTitle
		var target = (typeof(pTarget) == "string" && pTarget != "")? pTarget : QWIDGET_DEFAULT_TARGET
		var height
		var i;
		switch (target.toLowerCase()) {
			case "_blank":
				window.open(pURL)
				break

			case "_self":
				window.location.href = pURL
				break
			
			default:
				//Apertura in una widget. aggancia il body della widget e successivamente l'iframe
				var widget = QGetWidgetByName(target)
				var key = widget.id + QWIDGET_ID_SEP + "body"
				var body = document.getElementById(key)
				
							
				// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto commentata
				// \u00E8 stata sostituita dalla serie di istruzioni al di sotto di essa perch\u00E9 non era cross-browser
				//var iframe = body.firstChild
				var iframe;
				i = -1;
				do {
					i++;
					iframe = body.childNodes[i];					
				} while ((iframe.nodeName.toLowerCase()!="iframe") && (i<body.childNodes.length))


				//Normalizza l'URL. Se inizia con uno slash, antepone il percorso corrente.
				//var URL = (pURL.substr(0, 1) == "/")? QCurPath + pURL : pURL
				iframe.src = pURL;
				
				//Verifica se la widget target si trovi in un container alternato. In tal caso ne assicura la visibilit\u00E0.
			
				// Modifica di Claudio Vergamini 17/11/2009: la riga qu\u00EC sotto sostituisce quella commentata
				// al di sotto di essa perch\u00E9 quest'ultima non \u00E8 cross-browser
				QWidgetAlternateContainer(widget.getAttribute("name"))
				//QWidgetAlternateContainer(widget.name)
				
				//Adatta automaticamente l'altezza dell'iframe fino a fondo pagina
				if (pHeight == undefined || pHeight == null || pHeight == "") {
					if (navigator.appName == "Microsoft Internet Explorer") height = document.body.clientHeight - 200
					else height = window.innerHeight - 200
				}
				else height = pHeight
					iframe.style.height = height
					//Imposta il titolo
					QWidgetSetTitle(widget, title)
				break
		}
	}
	catch(e) {QException(e, "QWidgetURLOpen")}
}

//=====================================================================
function QWidgetURLClose(widgetName) {
	//Chiude una widget gestendo anche l'alternanza tra container alternativi.
	//Questa funzione non \u00E8 generalizzata.
	try {
		QWidgetAlternateContainer(widgetName, false)

		//Elimina il contenuto della widget dei contenuti
		var contentWidget = QGetElementsByAttribute("name", "ContentIFrame", "iframe")
		if (contentWidget[0]) contentWidget[0].src = ""
	}
	catch(e) {QException(e, "QWidgetURLClose")}
}