// ====================================================================================
// DATA CREAZIONE				: 21 settembre 2000
// TITOLO								: Utilities.js
// PROGRAMMATORE				: Alessandro Faustini
// REVISIONI
//		02-10-2008	v.0.7			Aggiunte funzioni GetClientWidth(), GetClientHeight(), ModifyRGBColor() e altre funzioni per manipolazione di colori e codici esadecimali
//		28/09/2008	v.0.6			Deprecata funzione 'nixyEventsHandler()' a favore di nixyEventsHandlerOnPtr()
//		28/09/2008	v.0.6			Deprecata funzione 'nixyEventsHandler()' a favore di nixyEventsHandlerOnPtr()
//		14/02/2006	v.0.5			Aggiunta funzione 'CheckField()'
//		09/05/2005	v.0.4			Aggiunta funzione 'VerifyDateData()'
//		17/04/2005	v.0.3			Aggiunta funzione 'nixyEventsHandler()'
//		13-03-2005	v.0.2			Aggiunte funzioni che usano DOM ed aggiornate funzioni esistenti
//		21-11-2000	v.0.1			Creazione pagina
//------------------------------------------------------------------------------------
// FUNZIONE DELLA PAGINA
// Funzioni pubbliche globali
//====================================================================================


function nixyBase_RightTrim(theString, charToTrim)
{
	while(theString.substring(0, charToTrim.length) == charToTrim)
	{
		theString = theString.substring(charToTrim.length, theString.length);
	}
	return(theString);
};



/* DEPRECATA */
function nixyEventsHandler(objId, evtName, functPtr, activate)
{
	/*=============================================
	Attiva e disattiva eventi degli oggetti
	Explorer ed il resto del mondo come sempre si comportano in maniera differente

	objId					l'id dell'oggetto DOM
	evtName				il nome dell'evento senza il prefisso 'on'
	funcPtr				il puntatore ad una funzione
	activate			se true attiva, diversamente disattiva l'evento
	===============================================*/
	if(activate == true)
	{
		if(navigator.appName.charAt(0) == "M")	// Explorer
			document.getElementById(objId).attachEvent("on"+evtName, functPtr);
  	else
			document.getElementById(objId).addEventListener(evtName, functPtr, false);
	}
	else
	{
		if(navigator.appName.charAt(0) == "M")	// Explorer
			document.getElementById(objId).detachEvent("on"+evtName, functPtr);
  	else
			document.getElementById(objId).removeEventListener(evtName, functPtr, false);
	}

}



/* Sostituisce nixyEventsHandler per usare un puntatore al posto dell'ID */
function nixyEventsHandlerOnPtr(objPtr, evtName, functPtr, activate)
{
	if(!objPtr)	return(false);
	/*=============================================
	Attiva e disattiva eventi degli oggetti
	Explorer ed il resto del mondo come sempre si comportano in maniera differente

	objPtr				il puntatore all'oggetto DOM
	evtName				il nome dell'evento senza il prefisso 'on'
	funcPtr				il puntatore ad una funzione
	activate			se true attiva, diversamente disattiva l'evento
	===============================================*/
	if(objPtr.attachEvent)	// Explorer
	{
		if(activate) 	objPtr.attachEvent("on"+evtName, functPtr);
		else 					objPtr.detachEvent("on"+evtName, functPtr);
	}
	else
	{
		if(activate)	objPtr.addEventListener(evtName, functPtr, false);
		else					objPtr.removeEventListener(evtName, functPtr, false);
	}
}



function disableObj(objId)
{
	/*=============================================
	Disabilita un oggetto DOM

	objId					l'id dell'oggetto DOM
	===============================================*/
	document.getElementById(objId).disabled=true;
}





function enableObj(objId)
{
	/*=============================================
	Abilita un oggetto DOM

	objId					l'id dell'oggetto DOM
	===============================================*/
	document.getElementById(objId).disabled=false;
}





function resetSelectObj(selectObjId)
{
	/*=============================================
	Elimina tutti gli items (option) di un oggetto
	SELECT (DOM)

	id					l'id dell'oggetto SELECT
	===============================================*/

	for(cnt=document.getElementById(selectObjId).length; cnt; cnt--)
		document.getElementById(selectObjId).remove(document.getElementById(selectObjId).selectedIndex);
}





function removeOptionFromSelect(selectObjId, idxToRemove)
{
	/*=============================================
	Elimina un item (option) di un oggetto
	SELECT (DOM)

	selectObjId				l'id dell'oggetto SELECT
	idxToRemove				l'indice dell'elemento da
										rimuovere
	===============================================*/

	if(idxToRemove > document.getElementById(selectObjId).length)
	{
		alert("removeOptionFromSelect: ("+selectObjId+")\nIndex is out of bound item");
		return;
	}
	document.getElementById(selectObjId).remove(idxToRemove);
}





function MoveRecordWithinSelectObjs(fromSelectId, toSelectId)
{
	/*=============================================
	Elimina un item (option) di un oggetto
	SELECT (DOM) e lo sposta in un altro

	fromSelectId	l'id dell'oggetto SELECT origine
	toSelectId		l'id dell'oggetto SELECT destinazione
	===============================================*/

	// Se non c'�selezione sposto il primo disponibile
	if(document.getElementById(fromSelectId).selectedIndex == -1)
  		document.getElementById(fromSelectId).selectedIndex = 0;

	// Ogni elemento che tolgo decrementa il parametro length della select quindi
	// incrementer�cnt solo quando non sposto elementi
	for(var cnt=0; cnt < document.getElementById(fromSelectId).options.length; cnt)
	{
 		if(document.getElementById(fromSelectId).options[cnt].selected)
 		{
 			addOptionInSelect(toSelectId
 											, document.getElementById(fromSelectId).options[cnt].value
 											, document.getElementById(fromSelectId).options[cnt].text);
 			removeOptionFromSelect(fromSelectId, cnt);
 			continue;
 		}
 		cnt++;
 	}
}



function addOptionInSelect(selectObjId, optionValue, optionText)
{
	var newOpt = document.createElement("option");
	newOpt.text = optionText;
	newOpt.value = optionValue;
	try
	{
		document.getElementById(selectObjId).add(newOpt, null); // standards compliant; ovviamente non va con Explorer
	}
	catch(ex)
	{
		document.getElementById(selectObjId).add(newOpt); // IExploder
	}
}





function UnselectDropDown(theDropDown)
{
	/*=============================================
			Resetta la selezione effettuata in un un oggetto SELECT

			theDropDown													un oggetto di tipo SELECT
	===============================================*/
	theDropDown.selectedIndex = 0;
}
//==================================================================================



function ChangeDropDownSelection(theDropDown, newItemValue, byTextFlag)
{
	/*========================================================================
			Sostituisce la selezione attuale con quella il cui valore o testo
			(a seconda del valore di (byTextFlag) �nella variabile (newItemValue)

			theDropDown													un oggetto di tipo SELECT
			newItemValue 													il nuovo valore o testo da cercare e selezionare
			byTextFlag																true = cerca nel campo .value / false = cerca nel campo .text
	==========================================================================*/
	// Resetto la selezione attuale
	theDropDown.selectedIndex = 0;

	for(cnt = 0; cnt < theDropDown.length; cnt++)
	{
		searchField = (byTextFlag ? "text" : "value");
		currentFieldValue = eval("theDropDown.options[cnt]." + searchField);

		// LASCIARE PER DEBUG...
		/*
			strTmp = "";
			for(cnt1 = 0; cnt1 < currentFieldValue.length; cnt1++)
				strTmp += "(" + currentFieldValue.charCodeAt(cnt1) + "-" + currentFieldValue.charAt(cnt1) + ")-(" + newItemValue.charCodeAt(cnt1) + "-" + newItemValue.charAt(cnt1) + ")\n";
			alert(strTmp);
		*/

		if(currentFieldValue == newItemValue)
		{
			theDropDown.selectedIndex = cnt;
			break;
		}
	}
}
//==================================================================================




function CharaptersCount(theTextArea,	theCounter,	maxChar, lang)
{
	/*========================================================================
	Effettua il conteggio dei caratteri inseriti in un campo di tipo textarea
	e se superano il numero massimo consentito blocca l'input segnalando
  l'errore all'utente

	theTextArea													un oggetto di tipo TEXTAREA
	theCounter 													di solito un DIV
	maxChar															il numero massimo di caratteri
	==========================================================================*/
	if(theTextArea.value.length	>	maxChar)
	{
		mesgTxt = "";
		switch(lang)
		{
			case "ENG": mesgTxt = "You can't insert over " + maxChar + " charapters"; break;
			case "ITA":
			default: 		mesgTxt = "Puoi inserire al massimo " + maxChar + " caratteri"; break;
		}
		alert(mesgTxt);
		tmp	=	"";
		for(cnt=0; cnt < maxChar;	cnt++)
				tmp	+= theTextArea.value.charAt(cnt);
		theTextArea.value	=	tmp;
	}
	if(theCounter.firstChild)
	{
		theCounter.removeChild(theCounter.firstChild);
		this.txtCount = null;
	}
	txtCount = document.createTextNode(theTextArea.value.length	+	" char (Max "	+	maxChar	+	")");
	theCounter.appendChild(txtCount);
}






function WriteMessage(theRowControl,	msg)
{
	if(theRowControl.firstChild)
	{
		theRowControl.removeChild(theRowControl.firstChild);
		this.txtMessage = null;
	}
	txtMessage = document.createTextNode(msg);
	theRowControl.appendChild(txtMessage);
}






function checkIfInputIsNaN(theInputField)
{
	/*========================================================================
	Viene chiamata da un evento 'onkeyup', se l'ultimo carattere inserito non
	�un numero, allora lo cancella.
	Il punto �consentito

	theInputField												un oggetto editabile
	==========================================================================*/
	if(theInputField.value.charAt(theInputField.value.length-1) < "0" || theInputField.value.charAt(theInputField.value.length-1) > "9")
	{
		if(theInputField.value.charAt(theInputField.value.length-1) == "." && theInputField.value.length > 1)
			return;
		theInputField.value = theInputField.value.substr(0 , theInputField.value.length-1);
		// Se l'utente tiene premuto il tasto quando scatta l'evento onkeyup ci sono pi caratteri non numerici
		checkIfInputIsNaN(theInputField);
	}
	return;
}
//==================================================================================





function ClearData(currentUrl)
{
	location.replace(currentUrl);
}




function DecToHex(n)
{
	var firstDigit, secondDigit;

	firstDigit = HexDigit(parseInt(n/16, 10));
	secondDigit = HexDigit((n % 16));
	return(firstDigit+secondDigit);
}



function HexDigit(n)
{
	switch(n)
	{
		case 15:	return("F");	break;
		case 14:	return("E");	break;
		case 13:	return("D");	break;
		case 12:	return("C");	break;
		case 11:	return("B");	break;
		case 10:	return("A");	break;
		default:	return(n.toString());	break;
	}
}




// CONVERT COMMAS
//--------------------------------------------------------------------------------------------------------------------------
function ConvertCommas(stringToModify)
{
	var modifiedString;
	modifiedString = "";
	for(cnt=0; cnt < stringToModify.length; cnt++)
	{
		modifiedString += (stringToModify.charAt(cnt) == "\'" ? "\'\'" : stringToModify.charAt(cnt));
	}
	return(modifiedString);
}
//==================================================================================




// VERIFY DATE DATA
//--------------------------------------------------------------------------------------------------------------------------
function VerifyDateData(theDateField, nameOfDateField)
{
	if(theDateField.value.length != 10)
	{
		if(theDateField.value.length == 0)
			alert("Please, specify the " + nameOfDateField + "\n                           (DD/MM/YYYY)");
		else
			alert("Please, verify the format of " + nameOfDateField + "\n                              (DD/MM/YYYY)");
		if(theDateField.type != "hidden")
			theDateField.focus();
		return(false);
	}
	else
	{
		if(isNaN(theDateField.value.substring(0,2)))
		{
			alert("Please, verify the day format of " + nameOfDateField + "\n                                (DD/MM/YYYY)");
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}
		else
			giorno = parseInt(theDateField.value.substring(0,2),10);

		if(isNaN(theDateField.value.substring(3,5)))
		{
			alert("Please, verify the month format of " + nameOfDateField + "\n                                     (DD/MM/YYYY)");
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}
		else
			mese = parseInt(theDateField.value.substring(3,5),10);

		if(isNaN(theDateField.value.substring(6,10)))
		{
			alert("Please, verify the year format of " + nameOfDateField + "\n                                     (DD/MM/YYYY)");
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}
		else
			anno = parseInt(theDateField.value.substring(6,10),10);

		d = new Date();

		/*if(anno < d.getFullYear()-1 || anno > d.getFullYear())
		{
			alert("Please, invalid year of " + nameOfDateField);
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}*/
		if(anno < 1900 || anno > d.getFullYear()+1)
		{
			alert("Please, year out of range !\nValid range is 1900 <--> " + parseInt(d.getFullYear()+1) + "\nin " + nameOfDateField);
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}
		if(mese < 1 || mese > 12)
		{
			alert("Please, invalid month of " + nameOfDateField + "\n                                (1-12)");
			if(theDateField.type != "hidden")
				theDateField.focus();
			return(false);
		}
		switch(mese)
		{
			case "01":	case "03": case "05": case "07": case "08": case "10": case "12":
				if(giorno < 1 || giorno > 31)
				{
					alert("Please, invalid day of " +  nameOfDateField + "\n                                (1-31)");
					if(theDateField.type != "hidden")
						theDateField.focus();
					return(false);
				}
			break;
			case "04":	case "06": case "09": case "11":
				if(giorno < 1 || giorno > 30)
				{
					alert("Please, invalid day of " + nameOfDateField + "\n                                (1-30)");
					if(theDateField.type != "hidden")
						theDateField.focus();
					return(false);
				}
			break;
			case "02":
				if(giorno < 1 || giorno > 29)
				{
					alert("Please, invalid day of " + nameOfDateField + "\n                                (1-" + (anno%4 ? "28" : "29") + ")");
					if(theDateField.type != "hidden")
						theDateField.focus();
					return(false);
				}
				if(giorno == 29 && anno%4)
				{
					alert("Please, invalid day of " + nameOfDateField + "\n                                (1-28)");
					if(theDateField.type != "hidden")
						theDateField.focus();
					return(false);
				}
			break;
		}
		// Se l'utente usa formati diversi da '-' (DD-MM-YYYY) per il separatore, lo sistemo da qui
		if(giorno.toString().length == 1)	giorno = "0" + giorno;
		if(mese.toString().length == 1)	mese = "0" + mese;
		theDateField.value = giorno + "-" + mese + "-" + anno
	}
	return(true);
}
//==================================================================================







/* CHECK FIELD

	fieldId
		Il campo da verificare

	fieldName
		Il nome del campo da verificare per i messaggi

	fieldType
		Tipo di campo in verifica, determina il comportamento della funzione
		- text:			Controlla che il campo 'fieldId' sia valorizzato o che lo sia almeno 'alternativeFieldId' se l'id non è nullo
		- email:		Controlla che il campo 'fieldId' contenga en'email in formato valido o che lo sia almeno 'alternativeFieldId'
								se l'id non è nullo
		- password:	Controlla che ci sia un password e che sia uguale a quella contenuta nel campo 'alternativeFieldId' se l'id
								non è nullo
		-list:			Controlla che sia selezionato almeno un item di una lista 'fieldId' o 'alternativeFieldId' se l'id non è nullo

	alternativeFieldId
		Contiene l'id del campo di confronto alternativo il cui utilizzo varia in base al tipo di campo definito da 'fieldType'
*/
//--------------------------------------------------------------------------------------------------------------------------
function CheckField(fieldId, fieldName, fieldType, alternativeFieldId)
{
	emptyField = false;
	alternateFieldVal = "";

	mainFieldVal = (document.getElementById(fieldId).tagName == "SELECT"
										? document.getElementById(fieldId).options[document.getElementById(fieldId).selectedIndex].value
												: document.getElementById(fieldId).value);



	if(alternativeFieldId)
		alternateFieldVal = (document.getElementById(alternativeFieldId).tagName == "SELECT"
														? document.getElementById(alternativeFieldId).options[document.getElementById(alternativeFieldId).selectedIndex].value
															 : document.getElementById(alternativeFieldId).value);

	if(mainFieldVal.length == 0)
	{
		if(fieldType == "password")
			emptyField = true; // La prima password non può mancare
		else if(alternateFieldVal.length == 0)
			emptyField = true;
		else if(fieldType == "email")
				mainFieldVal = alternateFieldVal;
	}

	if(emptyField)
	{
		if(fieldType == "list")
			alert("Selezionare un valore per il campo '"+fieldName+"'");
		else
			alert("Il campo '"+fieldName+"' e' obbligatorio");
		document.getElementById(fieldId).focus();
		return(false);
	}


	// 'email' e 'password' hanno bisogno ulteriori verifiche
	if(fieldType == "email")
	{
		if(mainFieldVal.indexOf("@") == -1 || mainFieldVal.indexOf(".") == -1)
		{
			alert("Il formato del campo '"+fieldName+"' non e' valido");
			document.getElementById(fieldId).focus();
			return(false);
		}
	}
	else if(fieldType == "password")
	{
		if(mainFieldVal != alternateFieldVal)
		{
			alert("Le due password non corrispondono");
			document.getElementById(fieldId).value = "";
			document.getElementById(alternativeFieldId).value = "";
			document.getElementById(fieldId).focus();
			return(false);
		}
	}
	return(true);
}
//==================================================================================




function GetClientWidth()
{
//	var val2 = 0;
//	var val3 = 0;

//	if(document.body.clientWidth && parseInt(document.body.clientWidth) > 0)
//		return(parseInt(document.body.clientWidth));
//	else	if(window.innerWidth && parseInt(window.innerWidth) > 0) // opera
//		return(parseInt(window.innerWidth));
	if(document.documentElement.clientWidth && parseInt(document.documentElement.clientWidth) > 0)
		return(parseInt(document.documentElement.clientWidth));
	else
		return(0);
}


function GetClientHeight()
{
//	if(document.body.clientHeight && parseInt(document.body.clientHeight) > 0)
//		return(parseInt(document.body.clientHeight));
//	else if(window.innerHeight && parseInt(window.innerHeight) > 0) // opera
//		return(parseInt(window.innerHeight));
	if(document.documentElement.clientHeight && parseInt(document.documentElement.clientHeight) > 0)
		return(parseInt(document.documentElement.clientHeight));
	else
		return(0);
}


function ModifyRGBColor(red, green, blue, delta, dark)
{
	var tmpRgb = new Array(0, 0, 0);
	tmpRgb[RED] = parseInt(red + (dark ? -delta : delta));
	tmpRgb[GREEN] = parseInt(green + (dark ? -delta : delta));
	tmpRgb[BLUE] = parseInt(blue + (dark ? -delta : delta));
	if(dark && tmpRgb[RED] < 0)							tmpRgb[RED] = 0;
	else if(!dark && tmpRgb[RED] > 255)			tmpRgb[RED] = 255;
	if(dark && tmpRgb[GREEN] < 0)						tmpRgb[GREEN] = 0;
	else if(!dark && tmpRgb[GREEN] > 255)		tmpRgb[GREEN] = 255;
	if(dark && tmpRgb[BLUE] < 0)						tmpRgb[BLUE] = 0;
	else if(!dark && tmpRgb[BLUE] > 255)		tmpRgb[BLUE] = 255;
	return(tmpRgb);
}

// 07/03/2008
// Dato un nome o un codice di colore html, lo traforma in RGB restituisce un array
function HTMLColorToRgb(htmlColorStr)
{
	var rgbArr = null;
	if(htmlColorStr == null)			return(null);
	else if(htmlColorStr.charAt(0) == "#" && htmlColorStr.length == 7)
	{
		var red = null;
		var green = null;
		var blue = null;
		if((red = HexToDecByte(htmlColorStr.substr(1,2))) == null)			return(null);
		if((green = HexToDecByte(htmlColorStr.substr(3,2))) == null)		return(null);
		if((blue = HexToDecByte(htmlColorStr.substr(5,2))) == null)			return(null);
		rgbArr = new Array(red, green, blue);
	}
	else
	{
		rgbArr = ColorNameToRGB(htmlColorStr);
		if(rgbArr == null)		return(null);
	}
	return(rgbArr);
}






function nixyBase_DarkColor(colorHex, decAmount)
{
	var r,g,b;
	r = HexToDecByte(colorHex.substr(1,2));
	g = HexToDecByte(colorHex.substr(3,2));
	b = HexToDecByte(colorHex.substr(5,2));
	r = DecToHexByte((r - decAmount <= 0 ? 0 : r - decAmount));
	g = DecToHexByte((g - decAmount <= 0 ? 0 : g - decAmount));
	b = DecToHexByte((b - decAmount <= 0 ? 0 : b - decAmount));
	return("#" + r + g + b);
}

function nixyBase_LightColor(colorHex, decAmount)
{
	var r,g,b;
	r = HexToDecByte(colorHex.substr(1,2));
	g = HexToDecByte(colorHex.substr(3,2));
	b = HexToDecByte(colorHex.substr(5,2));
	r = DecToHexByte((r + decAmount >= 255 ? 255 : r + decAmount));
	g = DecToHexByte((g + decAmount >= 255 ? 255 : g + decAmount));
	b = DecToHexByte((b + decAmount >= 255 ? 255 : b + decAmount));
	return("#" + r + g + b);
}


function nixyBase_ColorizeColor(colorHex, hexMasAkmount, lightMode)
{
	var r, g, b, mr, mg, mb;
	r = HexToDecByte(colorHex.substr(1,2));
	g = HexToDecByte(colorHex.substr(3,2));
	b = HexToDecByte(colorHex.substr(5,2));
	mr = HexToDecByte(hexMasAkmount.substr(1,2));
	mg = HexToDecByte(hexMasAkmount.substr(3,2));
	mb = HexToDecByte(hexMasAkmount.substr(5,2));

	if(lightMode)
	{
		r = DecToHexByte((r + mr >= 255 ? 255 : r + mr));
		g = DecToHexByte((g + mg >= 255 ? 255 : g + mg));
		b = DecToHexByte((b + mb >= 255 ? 255 : b + mb));
	}
	else
	{
		r = DecToHexByte((r - mr <= 0 ? 0 : r - mr));
		g = DecToHexByte((g - mg <= 0 ? 0 : g - mg));
		b = DecToHexByte((b - mb <= 0 ? 0 : b - mb));
	}

	return("#" + r + g + b);
}

// 07/03/2008
// Converte i colori standard del W3C in rgb, restituisce un array
function ColorNameToRGB(colorName)
{
	var rgbArr = null;

	switch(colorName)
	{
		case "aqua": 			rgbArr = new Array(0, 255, 255);		break;
		case "black":			rgbArr = new Array(0, 0, 0);				break;
		case "blue":			rgbArr = new Array(0, 0, 255);			break;
		case "fuchsia":		rgbArr = new Array(255, 0, 255);		break;
		case "gray":			rgbArr = new Array(128, 128, 128);	break;
		case "green":			rgbArr = new Array(0, 128, 0);			break;
		case "lime":			rgbArr = new Array(0, 255, 0);			break;
		case "maroon":		rgbArr = new Array(128, 0, 0);			break;
		case "navy":			rgbArr = new Array(0, 0, 128);			break;
		case "olive":			rgbArr = new Array(128, 128, 0);		break;
		case "purple":		rgbArr = new Array(128, 0, 128);		break;
		case "red":				rgbArr = new Array(255, 0, 0);			break;
		case "silver":		rgbArr = new Array(192, 192, 192);	break;
		case "teal":			rgbArr = new Array(0, 128, 128);		break;
		case "white":			rgbArr = new Array(255, 255, 255);	break;
		case "yellow":		rgbArr = new Array(255, 255, 0);		break;
		default:					rgbArr = null;											break;
	}
	return(rgbArr);
}


function DecToHexByte(n)
{
	var firstDigit, secondDigit;

	firstDigit = HexDigit(parseInt(n/16, 10));
	secondDigit = HexDigit((n % 16));
	return(firstDigit+secondDigit);
}


function HexToDecByte(xx)
{
	var digitLeft = null;
	var digitRight = null;
	if(xx.length < 2)		return(null);
	if((digitLeft = DecDigit(xx.charAt(0))) == null)		return(null);
	if((digitRight = DecDigit(xx.charAt(1))) == null)	return(null);

	return(digitLeft * 16 + digitRight);
}


function DecDigit(x)
{
	switch(x.toUpperCase())
	{
		case "F":		return(15);		break;
		case "E":		return(14);		break;
		case "D":		return(13);		break;
		case "C":		return(12);		break;
		case "B":		return(11);		break;
		case "A":		return(10);		break;
		default:		return(isNaN(x) ? null : parseInt(x));		break;
	}
}


function HexDigit(n)
{
	switch(n)
	{
		case 15:	return("F");	break;
		case 14:	return("E");	break;
		case 13:	return("D");	break;
		case 12:	return("C");	break;
		case 11:	return("B");	break;
		case 10:	return("A");	break;
		default:	return(n.toString());	break;
	}
}



// 24-06-2008: Svuota la struttura dom costruita dentro ad un contenitore
function nixyBase_ClearDomElement(delObjPtr, recursionLevel)
{
	if(!delObjPtr) return;
	if(!recursionLevel) recursionLevel = 0;

	//alert("Sono in: " + delObjPtr.nodeName + " ID:" + delObjPtr.id + " TAG: " + delObjPtr.nodeName + " LEVEL: " + recursionLevel + "\nDa " + delObjPtr.parentNode.nodeName);

	var cnt=0;
	while(delObjPtr.childNodes && delObjPtr.childNodes.length)
	{
		var objPtr = delObjPtr.childNodes[cnt];
		if(objPtr.nodeType != 1)	// Passano solo gli Elements (1)
			cnt++;
		else
		{
			// alert("Child id: " + objPtr.id + " - " + objPtr.nodeName + " LEVEL: " + recursionLevel);
			nixyBase_ClearDomElement(objPtr, recursionLevel+1);
			delete(objPtr);	// In teoria potrebbe aiutare a dealloccare memoria
		}
		if(cnt == delObjPtr.childNodes.length)	// Sono finiti gli elementi
			break;
	}
	// Svuoto il contenitore, non lo elimino
	if(recursionLevel)
	{
		 //alert("Distruggo: " + delObjPtr.nodeName + " ID:" + delObjPtr.id + " TAG: " + delObjPtr.nodeName + " LEVEL: " + recursionLevel + "\nDa " + delObjPtr.parentNode.nodeName);
		delObjPtr.parentNode.removeChild(delObjPtr);
		delete(delObjPtr);
	}
}

function ReplaceStaticText(textConteinerPtr, textToWrite)
{
	if(!textConteinerPtr)		return(false);

	if(textConteinerPtr.firstChild)
	{
		textConteinerPtr.removeChild(textConteinerPtr.firstChild);
		this.txtMessage = null;
	}
	txtMessage = document.createTextNode(textToWrite);
	textConteinerPtr.appendChild(txtMessage);

}