// INIZIO SEZIONE CAMPI


	function verificaCurriculum(){

		var fForm = document.forms["lavorare"];


		if( fForm.elements["posizione"].value == ''
			|| fForm.elements["allegato"].value == ''
			|| fForm.elements["cognome"].value == ''
			|| fForm.elements["nome"].value == ''
			|| fForm.elements["luogo"].value == ''
			|| fForm.elements["data"].value == ''
			|| fForm.elements["statocivile"].value == ''
			|| fForm.elements["indirizzo"].value == ''
			|| fForm.elements["citta"].value == ''
			|| fForm.elements["cap"].value == ''
			|| fForm.elements["mail"].value == ''
			|| fForm.elements["allegato"].value == ''
			|| !fForm.group1[0].checked 
		){
			alert('Compilare tutti i campi ed accettare Termini e condizioni');
			return;
		}
		fForm.submit();

	}


/* 
 * Funzione che permette di verificare se in un campo viene specificato un valore numerico.
 * Successivamente viene verificato se il valore ? intero e maggiore di zero.
 * Infine la funzione elimina eventuali "0" presenti davanti al numero.
 * Parametri:
 * fForm -> Riferimento al form dal quale recuperare il campo. (Ad esempio: document.forms["Ricerca"])
 * nomeCampo -> Nome del campo da verificare. (Ad esempio: "NUMCASSE")
 */ 
function verificaNumeroInteroPositivo(fForm, nomeCampo, sNomeClassApplicato){
	
	var nomeClass = fForm.elements[nomeCampo].className;
	
	if(nomeClass == null || nomeClass == "" || nomeClass == "inputError"){
		if(sNomeClassApplicato === undefined){
			nomeClass = "inputWrite";
		}else{
			nomeClass = sNomeClassApplicato;
		}
	}
	
	var sNum = fForm.elements[nomeCampo].value;
	sNum = ReplaceSubString(sNum, ".", "");
	if(sNum != ""){
		var pattern =/\b,\b/ig;					// Individua il carattere ","
		var sVal = sNum.replace(pattern,".");		// Lo sostituisce con un "."
		var iNum = Number(sVal);
	
		if(isNaN(iNum) == true){
			//E' necessario specificare un numero.
			alert(label.verificaNumeroInteroPositivo_mess1);	
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			return false;
		}//if
	
		if(sVal.indexOf(".") != -1){
			//Non pu? essere inserito un valore decimale.
			alert(label.verificaNumeroInteroPositivo_mess2);
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			return false;
		}//if
	
		if(iNum < 0){
			//Il valore non pu? essere negativo.
			alert(label.verificaNumeroInteroPositivo_mess3);
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			return false;
		}else{
			// Se il campo presenta come primo carattere uno 0 lo elimina.
			var sValore = fForm.elements[nomeCampo].value;
			
			if(sValore != "0"){
				while(sValore.charAt(0) == "0"){
					sValore = sValore.substring(1, sValore.length);
				}//while
				
				fForm.elements[nomeCampo].value = sValore;
			}//if
		}//if
	
		// Tutto corretto imposta il colore del campo standard
		fForm.elements[nomeCampo].className = nomeClass;
		
		//Inserisce il valore senza il carattere di separazione delle migliaia
		fForm.elements[nomeCampo].value = sNum;
	
	}//if
}


/* 
 * Funzione che permette di verificare se in un campo viene specificato un valore numerico
 * avente al massimo due cifre decimali.
 * Infine la funzione elimina eventuali "0" presenti davanti al numero.
 * Parametri:
 * fForm -> Riferimento al form dal quale recuperare il campo. (Ad esempio: document.forms["Ricerca"])
 * nomeCampo -> Nome del campo da verificare. (Ad esempio: "NUMCASSE")
 */ 
function verificaNumeroDecimaleFormato(fForm, nomeCampo, sNomeClassApplicato, maxNumeroCaratteri, maxNumeroDecimali){
	
	var nomeClass = fForm.elements[nomeCampo].className;
	
	if(nomeClass == null || nomeClass == "" || nomeClass == "inputError"){
		if(sNomeClassApplicato === undefined){
			nomeClass = "inputWrite";
		}else{
			nomeClass = sNomeClassApplicato;
		}
	}
		 
	
	var sNum = fForm.elements[nomeCampo].value;
	if(sNum != ""){
		sNum = ReplaceSubString(sNum, ".", "");
//		if(sNum.indexOf(",") != -1){
//			sNum = ReplaceSubString(sNum, ".", "");
//		}
		var pattern =/\b,\b/ig;						// Individua il carattere ","
		var sVal = sNum.replace(pattern,".");		// Lo sostituisce con un "."
		var iNum = Number(sVal);
	
		if(isNaN(iNum) == true){
			//E' necessario specificare un numero.
			alert(label.verificaNumeroDecimale_mess1);
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			return false;
		}//if

		if(maxNumeroCaratteri != null && maxNumeroCaratteri > 0){
		
			var iLunghezza = 0;

			if(sVal.indexOf(".") == -1){
				iLunghezza = sVal.length;
			}else{
				var sNumero = sVal.substring(0, (sVal.indexOf(".")));
				//alert("Numero : " + sNumero);
				iLunghezza = sNumero.length;
			}
			
			if (iLunghezza <= 0 || iLunghezza > maxNumeroCaratteri){
				alert(label.verificaNumeroDecimale_mess2);
				fForm.elements[nomeCampo].className = "inputError";
				fForm.elements[nomeCampo].focus();
				return false;
			}
		
		}
		
		
		if(sVal.indexOf(".") != -1){
			// Verifica che il numero di caratteri dopo il "." sia al massimo 2
			var sDecimali = sVal.substring((sVal.indexOf(".")+1), sVal.length);
			if(sDecimali.length > maxNumeroDecimali){
				//Il valore numerico deve presentare al massimo due cifre decimali.
				if(maxNumeroDecimali == 2){
					alert(label.verificaNumeroDecimale_mess3);
				}else if(maxNumeroDecimali == 3){
					alert(label.verificaNumeroDecimale_mess4);
				}else {
					alert(label.verificaNumeroDecimale_mess5);
				}
				fForm.elements[nomeCampo].className = "inputError";
				fForm.elements[nomeCampo].focus();
				return false;
			}//if
		}//if
	
		// Tutto corretto imposta il colore del campo standard
		fForm.elements[nomeCampo].className = nomeClass;
		
		// Sostituisce il PUNTO con una VIRGOLA
		var sNewVal = sVal.replace(/[.]/g,",");
		fForm.elements[nomeCampo].value = sNewVal;			

	}//if
}		


/*
 * Funzione che richiama la funzione verificaNumeroDecimale passando come ultimo parametro
 * 2 che indica il numero massimo di cifre decimali.
 */
function verificaNumeroDecimale(fForm, nomeCampo, sNomeClassApplicato, maxNumeroCaratteri){
	verificaNumeroDecimaleFormato(fForm, nomeCampo, sNomeClassApplicato, maxNumeroCaratteri, 2);
}


/*
 * Funzione che permette di verificare se il valore presente nel campo il cui nome ? stato passato 
 * come primo parametro ? maggiore del valore specificato nel campo il cui nome viene specificato 
 * come secondo parametro.
 */
function numeroMaggioreUguale(fForm, nomeCampo1, nomeCampo2){
 
	var sNum1 = fForm.elements[nomeCampo1].value;
	sNum1 = ReplaceSubString(sNum1, ".", "");
	if(sNum1 != ""){
		var pattern1 =/\b,\b/ig;					// Individua il carattere ","
		var sVal1 = sNum1.replace(pattern1,".");		// Lo sostituisce con un "."
		var iNum1 = Number(sVal1);
	
		var sNum2 = fForm.elements[nomeCampo2].value;
		sNum2 = ReplaceSubString(sNum2, ".", "");
		if(sNum2 != ""){
			var pattern2 =/\b,\b/ig;					// Individua il carattere ","
			var sVal2 = sNum2.replace(pattern2,".");		// Lo sostituisce con un "."
			var iNum2 = Number(sVal2);
			
			
			if(iNum1 >= iNum2){
				return true;
			}else{
				return false;
			}
			
		}
	}
	
	

}



/*
parametri opzionali
Ndec=numero di decimali
Smig=Separatore migliaia
Sdec=Separatore decimali
dec=parametro dei numeri decimali che viene passato nella conversione
*/
Number.prototype.format=function(Ndec,Smig,Sdec){
	
	Smig= Smig==undefined ? ".": Smig;
	Sdec= Sdec==undefined ? ",": Sdec;
	Ndec= Ndec==undefined ? 2 : Ndec;
	numo=this;
	num=!this.isNaN ? this.toString() : undefined;
	var numberstring ="";var j=i=0;
	idec=num.indexOf(".",0);
	dec=(idec!=-1)? num.substring(idec+1,num.length) : "0";
	while (num >= 1){
		numberstring =(Math.round(num-0.5) % 10) + numberstring;
		num=num/10;j++;
		if (num >= 1 && j==3){numberstring = Smig + numberstring ;j=0;}
		i++;
	}

	var d=0;
	var deco="";
	while(d < Ndec){d++; deco+="0";}
	repz=dec+deco;
	dec=(Ndec>dec.length)? repz: dec;
	addec=numberstring+Sdec+dec.substr(0,Ndec);
	numberstring=Ndec!=0 ? addec : numberstring;
	if(numo<1){numberstring="0"+numberstring};
	numberstring=num==undefined? num : numberstring;
	return numberstring;
}


function formatta(fElem){
	var numero = 0;
	
	if (fElem.value != ""){
		//Elimina i caratteri di separazione delle migliaia
		var valore = ReplaceSubString(fElem.value, ".", "");
		valore = ReplaceSubString(valore, ",", ".");
	
		numero = Number(valore);
	}
	
	
	if (numero > 0) {
		fElem.value = numero.format(2, ".", ",");
	}else{
		var numZero = 0;
		fElem.value = numZero.format(2, ".", ",");
	}

}


function formattaIntero(fElem){
	var numero = 0;

	if (fElem.value != ""){
		//Elimina i caratteri di separazione delle migliaia
		var valore = ReplaceSubString(fElem.value, ".", "");
		valore = ReplaceSubString(valore, ",", ".");
	
		numero = Number(valore);
	}
	
	if (numero > 0) {
		fElem.value = numero.format(0, ".", ",");
	}else{
		var numZero = 0;
		fElem.value = numZero.format(0, ".", ",");
	}

}


function formattaNumero(fElem) {
	var numero = 0;
	if ( (fElem.value == "") ||  ( isNaN(  ReplaceSubString(fElem.value, ",", ".") * 1 ) ) ) {
	} else {
		numero = Math.round( ( ReplaceSubString(fElem.value, ",", ".")*1 )*100)/100
	}
	
	var formattato = "";
	if (numero > 0) {
		formattato = "" + (numero + 0.001);
		formattato = ReplaceSubString(formattato, ".", ",");
		var iIndiceVirgola = formattato.indexOf(",");
		if ( (iIndiceVirgola != -1) && (formattato.length > (iIndiceVirgola+3) ) ) {
			formattato = formattato.substr(0,  iIndiceVirgola + 3);
			fElem.value = formattato;
		}
	}else{
		formattato = "0,00";
		fElem.value = formattato;
	}

}






function campoErrato(nomecampo) {
	nomecampo.className="inputError";
}


function campoGiusto(nomecampo, nuovoClass) {
	if(nuovoClass !== undefined){
		nomecampo.className = nuovoClass;
	}else{
		nomecampo.className = "inputWrite";
	}
}



// Variabili
var separators = new Array ('/', '.', '-', ',', ' ');
var days = new Array (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

/*
 * Verifica che il campo contenga un valore di tipo data e costruisce 
 * la stringa di presentazione secondo formato "GG/MM/YYYY"
 * Nella versione qui implementata, i formati di input accettati sono:
 * - G[G] {separatore} M[M] {separatore} [AA]AA	dove separatore ? uno 
 * degli elementi del vettore separators nella funzione setDateSeparator
 * - GGMM[AA]AA
 */
function VerificaData(Campo, Messaggio, sNomeClassApplicato) {
	//alert(Campo.value);
	//alert("Class: " + Campo.className);
	var nomeClass = Campo.className;
	
	if(nomeClass == null || nomeClass == "" || nomeClass == "inputError"){
		if(sNomeClassApplicato === undefined){
			nomeClass = "inputWrite";
		}else{
			nomeClass = sNomeClassApplicato;
		}
	}
	
	var d, m, y;
	// Si esegue il full trim del contenuto del campo data (es.: [bk] [bk] 1 2 [bk] [bk] 5 [bk] [bk] 0 2 --> 1 2 [bk] 5 [bk] 0 2) 
	var dateString = trim (Campo.value);
	// e si determina il separatore utilizzato
	var dateSeparator = setDateSeparator (dateString);
	if (Campo.value != "") {
	// Se il separatore ? uno degli elementi del vettore separators (vedi setDateSeparator), ...
	if (dateSeparator.length) {
		var dateArray = dateString.split(dateSeparator);
		// ... si verifica la consistenza del numero di elementi dell'array generato dal metodo split, segnalando eventuali inconsistenze
		if (dateArray.length != 3) {
			//La
			//deve avere il formato GG/MM/AAAA
			alert (label.VerificaData_mess1 + ' ' + Messaggio + ' ' + label.VerificaData_mess2);
			Campo.className = "inputError";
			Campo.focus();
			return false;
		}
		d = trim (dateArray[0]);
		m = trim (dateArray[1]);
		y = trim (dateArray[2]);
	}
	// Se il separatore non ? uno degli elementi del vettore separators (si assume che la data sia nel formato GGMM[AA]AA), ...
	else {
		// ... si verifica la consistenza della stringa in termini di lunghezza, segnalando eventuali inconsistenze
		if (dateString.length != 6 && dateString.length != 8) {
			alert (label.VerificaData_mess1 + ' ' + Messaggio + ' ' + label.VerificaData_mess2);
			Campo.className = "inputError";
			Campo.focus();
			return false;
		}
		d = dateString.substring (0, 2);
		m = dateString.substring (2, 4);
		y = dateString.substring (4, dateString.length);
	}
	// Si invoca la funzione InvalidDate per le verifiche formali degli elementi della data
	
	if (InvalidDate (d, m, y)) {
		//La
		//non ? valida
		alert (label.VerificaData_mess1 + ' ' + Messaggio + ' ' + label.VerificaData_mess3);
		Campo.className = "inputError";
		Campo.focus();
		return false;
	}

	// Se la data viene riconosciuta come valida, si rivalorizza il campo sorgente con la data in formato GG/MM/AAAA, avendo cura di calcolare l'elemento [AA] dell'anno, 
	// se non valorizzato, con l'analoga sequenza dell'anno corrente
	Campo.value = (d.length < 2 ? '0' : '') + d + '/' + (m.length < 2 ? '0' : '') + m + '/' + (y.length == 2 ?  new Date().getFullYear().toString().substring(0, 2): '') + y;
	
	// Tutto corretto imposta il colore del campo standard
	Campo.className = nomeClass;
	return true;
}	
}


/*
 * Verifica che il campo contenga un valore di tipo data e costruisce 
 * la stringa di presentazione secondo formato "GG/MM/YYYY"
 * Nella versione qui implementata, i formati di input accettati sono:
 * - G[G] {separatore} M[M] {separatore} [AA]AA	dove separatore ? uno 
 * degli elementi del vettore separators nella funzione setDateSeparator
 * - GGMM[AA]AA
 */
function VerificaData2 (Campo, Messaggio) {
	//alert(Campo.value);
	var nomeClass = Campo.className;
	
	if(nomeClass == null || nomeClass == "" || nomeClass == "inputError" ){
		nomeClass = "inputWrite";
	}

	var d, m, y;
	// Si esegue il full trim del contenuto del campo data (es.: [bk] [bk] 1 2 [bk] [bk] 5 [bk] [bk] 0 2 --> 1 2 [bk] 5 [bk] 0 2) 
	var dateString = trim (Campo.value);
	// e si determina il separatore utilizzato
	var dateSeparator = setDateSeparator (dateString);
	if (Campo.value != "") {
	// Se il separatore ? uno degli elementi del vettore separators (vedi setDateSeparator), ...
	if (dateSeparator.length) {
		var dateArray = dateString.split(dateSeparator);
		// ... si verifica la consistenza del numero di elementi dell'array generato dal metodo split, segnalando eventuali inconsistenze
		if (dateArray.length != 3) {
			//La
			//deve avere il formato GG/MM/AAAA
			alert (Messagio);
			Campo.focus();
			return false;
		}
		d = trim (dateArray[0]);
		m = trim (dateArray[1]);
		y = trim (dateArray[2]);
	}
	// Se il separatore non ? uno degli elementi del vettore separators (si assume che la data sia nel formato GGMM[AA]AA), ...
	else {
		// ... si verifica la consistenza della stringa in termini di lunghezza, segnalando eventuali inconsistenze
		if (dateString.length != 6 && dateString.length != 8) {
			alert (Messaggio);
			Campo.focus();
			return false;
		}
		d = dateString.substring (0, 2);
		m = dateString.substring (2, 4);
		y = dateString.substring (4, dateString.length);
	}
	// Si invoca la funzione InvalidDate2 per le verifiche formali degli elementi della data
	if (InvalidDate2 (d, m, y)) {
		//La
		//non ? valida
		alert (Messaggio);
		Campo.focus();
		return false;
	}
	// Se la data viene riconosciuta come valida, si rivalorizza il campo sorgente con la data in formato GG/MM/AAAA, avendo cura di calcolare l'elemento [AA] dell'anno, 
	// se non valorizzato, con l'analoga sequenza dell'anno corrente
	Campo.value = (d.length < 2 ? '0' : '') + d + '/' + (m.length < 2 ? '0' : '') + m + '/' + (y.length == 2 ?  new Date().getFullYear().toString().substring(0, 2): '') + y;
	
	// Tutto corretto imposta il colore del campo standard
	Campo.className = nomeClass;
	return true;
}	
}



/* 
 * Funzione che permette di eliminare gli spazi presenti prima e dopo una stringa.
 * NB: per capire questa funzione v. sintassi delle regular expression in JS
 */
function trim(aStr) {
	return ReplaceSubString(aStr.replace(/^\s{1,}/, "").replace(/\s{1,}$/, ""), "  "," ")
}

/* 
 * Funzione che permette di sostituire parte di una stringa con una nuova stringa.
 */
function ReplaceSubString(Stringa, StringaDaCercare, StringaDaSostituire) {
	temp = "" + Stringa;
	while (temp.indexOf(StringaDaCercare)>-1) {
		pos= temp.indexOf(StringaDaCercare);
		temp = "" + (temp.substring(0, pos) + StringaDaSostituire + temp.substring((pos + StringaDaCercare.length), temp.length));
	}
	return temp;
}


/*
 * Determinazione del separatore utilizzato. 
 * I caratteri accettati come separatori sono elencati come elementi 
 * dell'array separators.
 */
function setDateSeparator (dateString) {
	for (var i = 0; i < separators.length; i++){
		if (dateString.indexOf(separators[i]) != - 1){
			return (separators[i]);
		}
	}	
		
	// Se nessun separatore compare nella stringa sorgente, 
	// si assume l'assenza di separatori
	return ('');
}



/* 
 * Verifiche dimensionali e validazione giorno e mese.
 */
function InvalidDate (day, month, year) {
	var dateValue;
	
	if ( isNaN (day) || day.length <= 0 || day.length >= 3 ){
		alert(label.InvalidDate_giorno);
	   	return true;
	}  
	if ( isNaN (month) || month.length <= 0 || month.length >= 3 ){
		alert(label.InvalidDate_mese);
		return true;
	} 
	if ( isNaN (year) || year.length != 2 && year.length != 4 ){
		alert(label.InvalidDate_anno);
		return true;
	}
	
	if ((dateValue = parseInt (month, 10)) < 1 || dateValue > 12){
		alert(label.InvalidDate_mese);
		return true;
	}
	if ((dateValue = parseInt (day, 10)) < 1 || dateValue > DaysInMonth (month, year)){
		alert(label.InvalidDate_giorno);
		return true;
	}
	
	return false;
}


/* 
 * Verifiche dimensionali e validazione giorno e mese.
 * Funzione identica alla precedente ma senza alert di errore
 */
function InvalidDate2 (day, month, year) {
	var dateValue;
	
	if ( isNaN (day) || day.length <= 0 || day.length >= 3 ){
	   	return true;
	}  
	if ( isNaN (month) || month.length <= 0 || month.length >= 3 ){
		return true;
	} 
	if ( isNaN (year) || year.length != 2 && year.length != 4 ){
		return true;
	}
	
	if ((dateValue = parseInt (month, 10)) < 1 || dateValue > 12){
		return true;
	}
	if ((dateValue = parseInt (day, 10)) < 1 || dateValue > DaysInMonth (month, year)){
		return true;
	}
	
	return false;
}

function DaysInMonth (month, year) {		
	var dateValue;

	if ((dateValue =  parseInt (month, 10)) < 0 || dateValue > 12)
		return 0;
	if (dateValue == 2)
		return days[dateValue] + (LeapYear (year) ? 1 : 0);
	return days[dateValue];
}

function LeapYear (year) {
	var dateValue = parseInt (year, 10);
	return ((dateValue % 4) == 0) ? (((dateValue % 100) == 0) ? (((dateValue % 400) == 0) ? true : false) : true) : false;
}



/*
 * Funzione che permette di verificare se il valore specificato su di un campo ? una data valida.
 */
function validateDate(fld) {

    var mo, day, yr;
    var entry = fld.value;
    var reLong = /\b\d{1,2}[\/-]\d{1,2}[\/-]\d{4}\b/;
    var reShort = /\b\d{1,2}[\/-]\d{1,2}[\/-]\d{2}\b/;
    var valid = (reLong.test(entry)) || (reShort.test(entry));
    if (valid) {
        var delimChar = (entry.indexOf("/") != -1) ? "/" : "-";
        var delim1 = entry.indexOf(delimChar);
        var delim2 = entry.lastIndexOf(delimChar);
        day = parseInt(entry.substring(0, delim1), 10);
        mo = parseInt(entry.substring(delim1+1, delim2), 10);
        yr = parseInt(entry.substring(delim2+1), 10);
        // handle two-digit year
        if (yr < 100) {
            var today = new Date( );
            // get current century floor (e.g., 2000)
            var currCent = parseInt(today.getFullYear( ) / 100) * 100;
            // two digits up to this year + 15 expands to current century
            var threshold = (today.getFullYear( ) + 15) - currCent;
            if (yr > threshold) {
                yr += currCent - 100;
            } else {
                yr += currCent;
            }
        }
        var testDate = new Date(yr, mo-1, day);
        if (testDate.getDate( ) == day) {
            if (testDate.getMonth( ) + 1 == mo) {
                if (testDate.getFullYear( ) == yr) {
                    // fill field with database-friendly format
                    if (day<10) {
                    	day = "0" + day;
                    }
                    if (mo<10) {
                    	mo = "0" + mo;
                    }
                    fld.value = day + "/" + mo + "/" + yr;
                    return true;
                } else {
                		//L'anno inserito non ? corretto!
                    alert(label.validateDate_mess1);
                }
            } else {
            	//Il mese inserito non ? corretto!
                alert(label.validateDate_mess2);
            }
        } else {
        	//Il giorno inserito non ? corretto!
            alert(label.validateDate_mess3);
        }
    } else {
    	//La data deve essere nel formato gg/mm/aaaa!
        alert(label.validateDate_mess4);
    }
    return false;
}



/*
	 * Verifica che il numero sia compreso nel range specificato.
	 */
	function verificaRangeNumero(fForm, nomeCampo, valoreMinimo, valoreMassimo, sNomeClassApplicato){
		
		var bRitorna = false;
		
		var nomeClass = fForm.elements[nomeCampo].className;
	
		if(nomeClass == null || nomeClass == "" || nomeClass == "inputError"){
			if(sNomeClassApplicato === undefined){
				nomeClass = "inputWrite";
			}else{
				nomeClass = sNomeClassApplicato;
			}
		}
		
		var sNum = fForm.elements[nomeCampo].value;

		if(sNum == ""){
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			alert(label.verificaRangeNumero1 + " " + valoreMinimo + " " + label.verificaRangeNumero2 + " " + valoreMassimo);
			return false;
		}

		sNum = ReplaceSubString(sNum, ".", "");
		if(sNum != ""){
			var pattern =/\b,\b/ig;						// Individua il carattere ","
			var sVal = sNum.replace(pattern,".");		// Lo sostituisce con un "."
			var iNum = Number(sVal);
			//alert("iNum: " + iNum);
			
			if(iNum >= valoreMinimo && iNum <= valoreMassimo){
				bRitorna = true;
			}else{
				fForm.elements[nomeCampo].className = "inputError";
				fForm.elements[nomeCampo].focus();
				alert(label.verificaRangeNumero1 + " " + valoreMinimo + " " + label.verificaRangeNumero2 + " " + valoreMassimo);
				return false;
			}
		}
		
		// Tutto corretto imposta il colore del campo standard
		fForm.elements[nomeCampo].className = nomeClass;
		
		return bRitorna;
	}

	/* 
	 * Funzione che permette di verificare il numero di caratteri inseriti nel campo note.
	 */
	function checkLunghezzaMassima(nomeForm, nomeTextArea, maxCaratteri){
		var fForm = document.forms[nomeForm];
		var strLen = fForm.elements[nomeTextArea].value.length;

		if(strLen > maxCaratteri){
			alert(label.checkLunghezzaMassima1 + " " + maxCaratteri + " " + label.checkLunghezzaMassima2);
			fForm.elements[nomeTextArea].value = fForm.elements[nomeTextArea].value.substring(0, maxCaratteri);
		}
	}
	
	
	/*
	 * Funzione che permette di verificare se il valore numerico presente in uno specifico campo
	 * ? maggiore di una specifica soglia.
	 */ 
	function verificaSogliaMinimaNumero(fForm, nomeCampo, valoreMinimo, sNomeClassApplicato){
		
		var bRitorna = false;
		
		var nomeClass = fForm.elements[nomeCampo].className;
	
		if(nomeClass == null || nomeClass == "" || nomeClass == "inputError"){
			if(sNomeClassApplicato === undefined){
				nomeClass = "inputWrite";
			}else{
				nomeClass = sNomeClassApplicato;
			}
		}
		
		var sNum = fForm.elements[nomeCampo].value;

		if(sNum == ""){
			fForm.elements[nomeCampo].className = "inputError";
			fForm.elements[nomeCampo].focus();
			alert(label.verificaSogliaMinima + " " + valoreMinimo);
			return false;
		}

		sNum = ReplaceSubString(sNum, ".", "");
		if(sNum != ""){
			var pattern =/\b,\b/ig;						// Individua il carattere ","
			var sVal = sNum.replace(pattern,".");		// Lo sostituisce con un "."
			var iNum = Number(sVal);
			//alert("iNum: " + iNum);
			
			if(iNum > valoreMinimo){
				bRitorna = true;
			}else{
				fForm.elements[nomeCampo].className = "inputError";
				fForm.elements[nomeCampo].focus();
				alert(label.verificaSogliaMinima + " " + valoreMinimo);
				return false;
			}
		}
		
		// Tutto corretto imposta il colore del campo standard
		fForm.elements[nomeCampo].className = nomeClass;
		
		return bRitorna;
	}



// FINE SEZIONE CAMPI


function goToHomePage(){
	window.top.frames["Titolo"].vaiHomePage();
}

function imgToolbarOver(me){
	if ( me.className == "imgToolbarEnabled" ){
		me.className = "imgToolbarEnabledOver";
	}
}

function imgToolbarOut(me){
	if ( me.className == "imgToolbarEnabledOver" ){
		me.className = "imgToolbarEnabled";
	}
}


/*
Controlla (attraverso lo stile corrente) che l'immagine il cui nome viene passato come parametro
sia abilitata o meno. Attenzione: sul documento deve esserci una sola immagine con il nome indicato.
*/
function tastoAbilitato(img){
	var tasto;
	if(document.all){
		tasto = document.all[img];
	}else{
		tasto = document.getElementById(img);
	}
	if (tasto.className == "imgToolbarEnabled" ||
		tasto.className == "imgToolbarEnabledOver" || 
		tasto.className == "imgEnabled"){
		return true;
	}
	return false;
}
/*
 IN ORDINI ERA 
 function tastoAbilitato(img){
	var tasto;
	if(document.all){
		tasto = document.all[img];
	}else{
		tasto = document.getElementById(img);
	}
	if (tasto.className == "imgToolbarEnabled" ||
		tasto.className == "imgToolbarEnabledOver"){
		return true;
	}
	return false;
}
*/


/*
Abilito o disabilito (assegnando uno stile opportuno) l'immagine il cui nome viene 
passato come primo parametro; il secondo parametro indica se abilitare (true) o 
disabilitare (false) l'immagine. Attenzione: sul documento deve essere presente
un'unica immagine con il nome specificato nel parametro.
*/
function abilitaTasto(img,abilita){
	if ( abilita ){
		if(document.all){
			//solo se l'immagine esiste
			if(document.all[img]){
				document.all[img].className = "imgToolbarEnabled";
			}
		}else{
			element = document.getElementById(img);
			if(element){
				element.className="imgToolbarEnabled";
			}
		}
	}else{
		if(document.all){
			//solo se l'immagine esiste
			if(document.all[img]){
				document.all[img].className = "imgToolbarDisabled";		
			}
		}else{
			element = document.getElementById(img);
			if(element){
				element.className="imgToolbarDisabled";
			}
		}
	}
}

function cambiaCssImmagine(img, nomeClass){
	if(document.all){
		if(document.all[img]){
			document.all[img].className = nomeClass;
		}
	}else{
		element = document.getElementById(img);
		if(element){
			element.className=nomeClass;
		}
	}
}

function maximizeWindow( ) {

    var offset = (navigator.userAgent.indexOf("Mac") != -1 || 
                  navigator.userAgent.indexOf("Gecko") != -1 || 
                  navigator.appName.indexOf("Netscape") != -1) ? 0 : 4;
    window.moveTo(-offset, -offset);
    window.resizeTo(screen.availWidth + (2 * offset), 
                   screen.availHeight + (2 * offset));

}

function openPopUp(URL, NomeFinestra, SpazioOr, SpazioVer){
	var larghezza = screen.availWidth - SpazioOr - 10;
	var altezza = screen.availHeight - SpazioVer - 50;
	var newFin = window.open(URL,NomeFinestra,"status ,fullscreen=no,toolbar=no,location=no,scrollbars=yes,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + (SpazioVer / 2) + ",left=" + (SpazioOr / 2),false);
	if (newFin != null) {
		newFin.focus();
	}
}//openPopUp

function openPopUpNoScroll(URL, NomeFinestra, SpazioOr, SpazioVer){
	var larghezza = screen.availWidth - SpazioOr - 10;
	var altezza = screen.availHeight - SpazioVer - 50;
	var newFin = window.open(URL,NomeFinestra,"status ,fullscreen=no,toolbar=no,location=no,scrollbars=auto,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + (SpazioVer / 2) + ",left=" + (SpazioOr / 2),false);
	if (newFin != null) {
		newFin.focus();
	}
}//openPopUpNoScroll

function formattaData(formato,datainiziale){
	var data = "";
	if(formato=="dd/MM/yyyy"){
		dd = datainiziale.substring(0,datainiziale.indexOf("/"));
		mm = datainiziale.substring(datainiziale.indexOf("/") + 1,datainiziale.lastIndexOf("/"));
		yyyy = datainiziale.substring(datainiziale.lastIndexOf("/")+1,datainiziale.length)
		data = yyyy + "-" + mm + "-" + dd;
	}else if(formato=="MM/dd/yyyy"){
		mm = datainiziale.substring(0,datainiziale.indexOf("/"));
		dd = datainiziale.substring(datainiziale.indexOf("/") + 1,datainiziale.lastIndexOf("/"));
		yyyy = datainiziale.substring(datainiziale.lastIndexOf("/")+1,datainiziale.length);
		data = yyyy + "-" + mm + "-" + dd;
	}
	return data;
}

function abilitaGruppoImmagini(fForm,array,abilita){
	if(document.all){
		for ( var indice = 0; indice < array.length; indice++ ) {
			var campo = fForm.elements[ array[indice] ];
			if(campo){
				if (abilita == true){
					campo.className="imgToolbarEnabled";
				}else{
					campo.className="imgToolbarDisabled";
				}
			}
		}
	}else{
		for ( var indice = 0; indice < array.length; indice++ ) {
			element = document.getElementById(array[indice]);
			if(element){
				if (abilita == true){
					element.className="imgToolbarEnabled";
				}else{
					element.className="imgToolbarDisabled";
				}
			}
		}
	}
}

function abilitaGruppoBottoni(fForm,array,abilita){
	if(document.all){
		for ( var indice = 0; indice < array.length; indice++ ) {
			var campo = fForm.elements[ array[indice] ];
			if(campo){
				if (abilita == true){
					campo.className="imgToolbarEnabled";
					campo.disabled = false;	
				}else{
					campo.className="imgToolbarDisabled";
					campo.disabled = true;		
				}
			}
		}
	}else{
		for ( var indice = 0; indice < array.length; indice++ ) {
			element = document.getElementById(array[indice]);
			if(element){
				if (abilita == true){
					element.className="imgToolbarEnabled";
					element.disabled = false;	
				}else{
					element.className="imgToolbarDisabled";
					element.disabled = true;			
				}
			}
		}
	}
}

function abilitaGruppoSelect(fForm,array,abilita){
	if(document.all){
		for ( var indice = 0; indice < array.length; indice++ ) {
			var campo = fForm.elements[ array[indice] ];
			if (abilita == true){
				campo.disabled = false;	
			}else{
				campo.disabled = true;		
			}
		}
	}else{
		for ( var indice = 0; indice < array.length; indice++ ) {
		    valore = array[indice];
			element = document.getElementById(valore);
			if(element){
				if (abilita == true){
					element.disabled = false;	
				}else{
					element.disabled = true;			
				}
			}
		}
	}
}

function disabilitaHREF(nomeTasto,e){
	var classNameValue;
	if(document.all){
		classNameValue = document.all[ nomeTasto ].className;
	}else{
		classNameValue = document.getElementById( nomeTasto ).className;
	}	
	if((classNameValue == "imgToolbarDisabled") || (classNameValue == "imgDisabled")){
		if(document.all){
			if(e != null){
				e.returnValue=false;
			}
		}else{
			if(Event != null){
				e.preventDefault(); 
			}
		}
	}
}

/*
 IN ORDINI e CLASSIFICAZIONI e ABACO
 function disabilitaHREF(nomeTasto, e){

	var classNameValue;
	if(document.all){
		//alert("document.all[ nomeTasto ]: " + document.all[ nomeTasto ]);
		//alert("document.all[ nomeTasto ].className: " + document.all[ nomeTasto ].className);
		classNameValue = document.all[ nomeTasto ].className;
	}else{
		classNameValue = document.getElementById( nomeTasto ).className;
	}
	if(classNameValue == "imgToolbarDisabled"){
		if(window.event != null){
			window.event.returnValue=false;
		}else{
			e.preventDefault();
		}
	}
}
*/

function disabilitaHREFElenco(nomeTasto, e){
	var classNameValue;
	if(document.all){
		var valoriCampo = document.all[nomeTasto];
		
	}else{
		var valoriCampo = document.getElementById( nomeTasto );
	}
		//alert(valoriCampo.lenght);
		if(valoriCampo.length === undefined){
			classNameValue = valoriCampo.className;
		}else{
			classNameValue = valoriCampo[0].className;
		}
	//alert('classNameValue ' + classNameValue);
	if(classNameValue == "imgDisabled"){
		if(window.event != null){
			window.event.returnValue=false;
		}else{
			e.preventDefault();
		}
	}
}

/*
 * Funzione che permette di ripulire solo i campi specificati
 */
/* NON VIENE PIU' UTILIZZATA DAL 08-08-2006
function pulisciCampiSpecifici(fForm,array){
	for ( var indice = 0; indice < array.length; indice++ ) {
		if ( fForm.elements[ array[indice] ] !== undefined &&
			fForm.elements[ array[indice] ] != null ) {
			var campo = fForm.elements[ array[indice] ];
			campo.value = "";
		}
	}
}
*/


function pulisciCampiSpecifici(fForm,array){
	for (var i = 0; i < array.length; i++ ) {
		if (fForm.elements[array[i]] !== undefined && fForm.elements[array[i]] != null) {
			var campo = fForm.elements[array[i]];
			
			if (campo.type == "text" || 
				campo.type == "textarea" ||
				campo.type == "password" ||
				campo.type == "hidden") {
				campo.value = "";
			} else if (campo.type == "checkbox" ||
					   campo.type == "radio") {
				campo.status = false;
			} else if (campo.type == "select-one" ||
					   campo.type == "select-multiple") {
				campo.selectedIndex = 0;
			}
		}
	}
}



/*
 * Funzione che permette di ripulire tutti i campi tranne quelli specificati.
 */
function pulisciCampiNoSpecifici( fForm, array ) {
	for ( var indice = 0; indice < fForm.length; indice++ ) {
		var campo = fForm.elements[indice];
		var cancella = true;
		for ( var i = 0; i < array.length; i++ ) {
			if( array[i] == campo.name ){
				cancella = false;
			}
		}
		
		if(cancella == true){
			campo.value = "";
		}
	}
}

/*
function cancellaContenuto(nomeForm,arrayNomeCampi){
	var fForm = document.forms[nomeForm];
	for ( var indice = 0; indice < arrayNomeCampi.length; indice++ ) {
		var campo = fForm.elements[ arrayNomeCampi[indice] ];
		campo.value = "";
	}
}
*/

function cancellaContenuto(nomeForm,arrayNomeCampi,nomeTasto){
	if ( nomeTasto != null && nomeTasto != "" && !tastoAbilitato(nomeTasto) ) {
		return;
	}
	var fForm = document.forms[nomeForm];
	for ( var indice = 0; indice < arrayNomeCampi.length; indice++ ) {
		var campo = fForm.elements[ arrayNomeCampi[indice] ];
		campo.value = "";
	}
}


/*
Azioni da intraprendere quando il mouse entra in una cella di tabella
Queste azioni al termini delle sostituzioni di stili2, andranno tolte e rimangono solamente:tabMouseOver e tabMouseOut
*/
function cellTabMouseOver( tab ) {
	if ( tab.className == "cellTabDisabled" ) {
		tab.className = "cellTabOver";
	}
}

/*
Azioni da intraprendere quando il mouse esce da una cella di tabella
Queste azioni al termini delle sostituzioni di stili2, andranno tolte e rimangono solamente:tabMouseOver e tabMouseOut
*/
function cellTabMouseOut( tab ) {
	if ( tab.className == "cellTabOver" ) {
		tab.className = "cellTabDisabled";
	}
}

/*
NUOVE Azioni da intraprendere quando il mouse entra in una cella di tabella
*/
function tabMouseOver( tab ) {
	if ( tab.className == "tabDisabilitato" ) {
		tab.className = "tabOver";
	}
}

/*
NUOVE Azioni da intraprendere quando il mouse esce da una cella di tabella
*/
function tabMouseOut( tab ) {
	if ( tab.className == "tabOver" ) {
		tab.className = "tabDisabilitato";
	}
}

/*
Svuota il testo contenuto o azzera la selezione dei campi
contenuti nella form il cui nome viene specificato come parametro.
*/
function pulisciCampi( fForm ) {

	for ( var indice = 0; indice < fForm.length; indice++ ) {
		var campo = fForm.elements[indice];
		
		if ( campo.type == "text" || 
			 campo.type == "textarea" ||
			 campo.type == "password" ||
			 campo.type == "hidden" ) {
			campo.value = "";
		} else if ( campo.type == "checkbox" ||
					campo.type == "radio" ) {
			campo.status = false;
		} else if ( campo.type == "select-one" ||
					campo.type == "select-multiple" ) {
			campo.selectedIndex = 0;
		}
		
	}
}


//Funzione che abilita tutti i campi che iniziano con la stessa stringa
	function abilitaCampiPerIniziale(fForm, nomeIniziale, bValore){
		for (var indice = 0; indice < fForm.length; indice++) {
			var campo = fForm.elements[indice];
			if((campo.name).indexOf(nomeIniziale, 0) != -1){
				campoCorrente = campo.name;
				abilita(fForm, Array(campoCorrente), bValore);
			}
		}
	}


/*
Abilita o disabilita i campi di una form.
I parametri corrispondono al nome della form contenente i campi, ad un
Array di stringhe con i nomi dei campi e ad un valore booleano per 
specificare se abilitare (true) o disabilitare (false) tutti i campi contenuti
nell'Array
*/
function abilita( fForm, array, abilita ) {
	for ( var indice = 0; indice < array.length; indice++ ) {
		if ( fForm.elements[ array[indice] ] !== undefined &&
			fForm.elements[ array[indice] ] != null ) {
			var campo = fForm.elements[ array[indice] ];
			if ( campo.type == "text" || 
				 campo.type == "password" ||
				 campo.type == "hidden" ||
				 campo.type == "file" ) {
				campo.readOnly = !abilita;
				if ( abilita ) {
					campo.className ="inputWrite";
				} else {
					campo.className = "inputReadOnly";
				}
			} else if (campo.type == "textarea"){
				campo.readOnly = !abilita;
				if ( abilita ) {
					campo.className ="inputWrite";
				} else {
					campo.className = "inputReadOnlyTextArea";
				}
			} else if ( campo.type == "select-one" ||
						campo.type == "select-multiple" ) {
				campo.disabled = !abilita;
				if ( abilita ) {
					campo.className ="inputWriteSelect";
				} else {
					campo.className = "inputReadOnly";
				}
			} else if ( campo.type == "checkbox" ){
				campo.disabled = !abilita;
				if ( abilita ) {
					campo.className ="inputWriteTransparent";
				} else {
					campo.className = "inputReadOnlySelectRadio";
				}
			} else if(((campo[0]) && (campo[0].type == "radio")) || (campo.type == "radio")){
				if(campo.length != undefined){
					//Ci sono pi? pulsanti radio
					for(j=0; j<campo.length;j++){
						campo[j].disabled=!abilita;
						if ( abilita ) {
							campo[j].className ="inputWriteTransparent";
						} else {
							campo[j].className = "inputReadOnlySelectRadio";
						}
					}
				}else{
					//C'? solamente un pulsante radio
					campo.disabled=!abilita;
					if ( abilita ) {
						//campo.className ="inputWrite";
						campo.className ="inputWriteTransparent";
					} else {
						campo.className ="inputReadOnlySelectRadio";
						//campo.className = "inputWriteTransparent";
					}
				}
			}
		}
	}
}


function abilitaInizioNome(fForm, inizioNome, abilita){

	//alert("Inizio abilitaInizioNome");

	var array = fForm.elements;
		
	//alert("Elementi array: " + array.length);

		for ( var indice = 0; indice < array.length; indice++ ) {
		
		//alert("Nome elemento: " + array[indice].name);
		
		if ( array[indice] !== undefined &&
			 array[indice] != null &&
			 array[indice].name !== undefined &&
			 array[indice].name.indexOf(inizioNome) == 0) {

			 //alert("Il campo inizia per: " + inizioNome);

			var campo = array[indice];
			if ( campo.type == "text" || 
				 campo.type == "textarea" ||
				 campo.type == "password" ||
				 campo.type == "hidden" ) {
				campo.readOnly = !abilita;
				if ( abilita ) {
					campo.className ="inputWrite";
				} else {
					campo.className = "inputReadOnly";
				}
			} else if ( campo.type == "select-one" ||
						campo.type == "select-multiple" ) {
				campo.disabled = !abilita;
				if ( abilita ) {
					campo.className ="inputWriteSelect";
				} else {
					campo.className = "inputReadOnlySelectRadio";
				}
			} else if ( campo.type == "checkbox" ){
				campo.disabled = !abilita;
				if ( abilita ) {
					campo.className ="inputWriteTransparent";
				} else {
					campo.className = "inputReadOnlySelectRadio";
				}
			} else if(((campo[0]) && (campo[0].type == "radio")) || (campo.type == "radio")){
				if(campo.length != undefined){
					//Ci sono pi? pulsanti radio
					for(j=0; j<campo.length;j++){
						campo[j].disabled=!abilita;
						if ( abilita ) {
							campo[j].className ="inputWriteTransparent";
						} else {
							campo[j].className = "inputReadOnlySelectRadio";
						}
					}
				}else{
					//C'? solamente un pulsante radio
					campo.disabled=!abilita;
					if ( abilita ) {
						//campo.className ="inputWrite";
						campo.className ="inputWriteTransparent";
					} else {
						campo.className ="inputReadOnlySelectRadio";
						//campo.className = "inputWriteTransparent";
					}
				}
			}
		}
	}
	
}



/*
 * Ritorna il numero di giorni tra due date 
 * (le due date devono essere passate come stringhe nel formato GG/MM/AAAA)
 * Valore > 0 se la data fine ? > della data di inizio
 */
function DayDifference(DataIniziale, DataFinale) {
	var PrimaData = new Date(parseInt(DataIniziale.substring(6, 10), 10), (parseInt(DataIniziale.substring(3, 5), 10)-1), parseInt(DataIniziale.substring(0, 2), 10));
	var UltimaData = new Date(parseInt(DataFinale.substring(6, 10), 10), (parseInt(DataFinale.substring(3, 5), 10)-1), parseInt(DataFinale.substring(0, 2), 10));
	
	// Questo controllo serve quando cambia l'ora in primavera
	var varMin = 0;
	if(Math.abs(UltimaData.getTimezoneOffset() - PrimaData.getTimezoneOffset()) > 0 ){
		varMin = Math.abs(UltimaData.getTimezoneOffset() - PrimaData.getTimezoneOffset());
	}
	var difMin = (UltimaData.getTime() - PrimaData.getTime())/1000/60;
	var dif = Math.floor((difMin+varMin)/60/24);
	
	return dif;
	
	/*
	var DataIniziale = sDataOrdine;
	var DataFinale = sDataConsegna;
	var PrimaData = new Date(parseInt(DataIniziale.substring(6, 10), 10), (parseInt(DataIniziale.substring(3, 5), 10)-1), parseInt(DataIniziale.substring(0, 2), 10));
	alert("PrimaData: " + PrimaData);
	alert("Dif in min da 0: " + PrimaData.getTimezoneOffset());
	var UltimaData = new Date(parseInt(DataFinale.substring(6, 10), 10), (parseInt(DataFinale.substring(3, 5), 10)-1), parseInt(DataFinale.substring(0, 2), 10));
	alert("UltimaData: " + UltimaData);
	alert("Dif in min da 0: " + UltimaData.getTimezoneOffset());
	var varMin = 0;
	if(Math.abs(UltimaData.getTimezoneOffset() - PrimaData.getTimezoneOffset()) > 0 ){
		varMin = Math.abs(UltimaData.getTimezoneOffset() - PrimaData.getTimezoneOffset());
	}
	var difMin = (UltimaData.getTime() - PrimaData.getTime())/1000/60;
	var dif = Math.floor((difMin+varMin)/60/24);
	alert("Dif: " + dif);
	 */
}



/***********************************************INIZIO MODIFICHE MICHELA 16/11/2004*****************************************************/

/*
* Funzione che ritorna un array contenente il numero dei giorni di ogni mese tenendo conto degli anni bisestili
*/
function arrayMesi(anno){
	var vArrayMesi = null;
	if(anno % 4 == 0){
		//L'anno ? bisestile
		vArrayMesi = Array(31,29,31,30,31,30,31,31,30,31,30,31);
	}else{
		//l'anno non ? bisestile
		vArrayMesi = Array(31,28,31,30,31,30,31,31,30,31,30,31);
	}
	return vArrayMesi;
}

/*
* Funzione che a partire da una data iniziale, restituisce una data incrementata di un numero di mesi specificato.
*sDataIniziale="gg/mm/aaaa"
*/
function incrementoMese(sDataIniziale, numeroMesi){
	
	//Ricavo l'oggetto data iniziale su cui effettuale successivamente l'incremento
	var Data = new Date(parseInt(sDataIniziale.substring(6, 10), 10), (parseInt(sDataIniziale.substring(3, 5), 10)-1), parseInt(sDataIniziale.substring(0, 2), 10));
	
	//Ricavo il mese di inizio (da 0 a 11)
	var MeseInizio = Data.getMonth();
	//Ricavo l'anno di inizio
	var AnnoInizio = Data.getYear();
	//Ricavo il giorno di inizio
	var GiornoInizio = Data.getDate();
	
	//Totale mesi: mese corrente + incremento
	var totaleMesi = MeseInizio + parseInt(numeroMesi);
	
	//Effettuo la divisione tra totale mesi e 12
	//La parte intera della divisione d? il numero con cui deve essere incrementato l'anno attuale	
	var incrementoAnno = parseInt(totaleMesi / 12);

	//Setto nella data di partenza il nuovo anno
	var annoNuovo = AnnoInizio + incrementoAnno;
	Data.setYear(parseInt(annoNuovo));
	
	//Effettuo l'operazione: totale mesi modulo 12
	//Il risultato definisce il nuovo mese
	var nuovoMese = totaleMesi % 12;
	//Setto nella data il nuovo mese
	Data.setMonth(parseInt(nuovoMese));

	//In base all'anno, ricavo l'array contenente il numero di giorni per ogni mese
	var vArrayMesi = arrayMesi(annoNuovo);
	
	//Calcolo il numero di giorni del nuovo mese corrente
	var giorniDelMese = vArrayMesi[nuovoMese];
	
	//Se il giorno della data di inizio ? <= dei giorni del mese, allora lo mantengo,
	//altrimenti se il giorno di inizio ? > del numero di giorni del mese allora setto come giorno della data corrente,
	//l'ultimo giorno del mese
	var nuovoGiorno = null;
	
	if(GiornoInizio <= giorniDelMese){
		nuovoGiorno = GiornoInizio;
	}else{
		//il giorno ? pari all'ultimo del mese
		nuovoGiorno = giorniDelMese;
	}

	Data.setDate(parseInt(nuovoGiorno));

	//mistero: se viene omesso, nel caso in cui GiornoInizio > giornoDelMese, il mese viene incrementato di 1
	Data.setMonth(parseInt(nuovoMese));

	return Data;
}

/*
* Funzione che controlla che una specifica data passata in stringa gg/mm/aaaa
* ? minore di una data limite calcolata sulla basa di una data iniziale e aggiungendo un incremento di mesi.
*Se tale incremento di mesi ? pari a "0" non esiste una data limite ed il controllo non viene effettuato.
*/
function controllaDataFine(sDataIniziale,numeroMesi,sDataFinale){
	//Booleano che indica se la data finale ? minore della data limite
	var corretta = true;
	
	//se numeroMesi!=0 effettuo il controllo,
	//altrimenti, non esiste una data limite, e la data finale ? sempre corretta
	if((numeroMesi != 0) || (numeroMesi != "0")){
		//calcolo la data limite
		var DataLimite = incrementoMese(sDataIniziale, numeroMesi);
		
		//Trasformo in data la stringa di data fine per effettuare il confronto con la data limite
		var DataFine = new Date(parseInt(sDataFinale.substring(6, 10), 10), (parseInt(sDataFinale.substring(3, 5), 10)-1), parseInt(sDataFinale.substring(0, 2), 10));
		
		//Effettuo il controllo che la data fine sia maggiore o uguale della data limite, in questo caso la data fine non passa
		//il controllo e perci? non ? corretta.
		if(DataFine.getTime() >= DataLimite.getTime()){
			corretta = false;
		}
	}
	return corretta;
}

/*
* Funzione che ritorna true se la data passata come ultimo parametro ? compresa tra data inizio e data fine,
* false se la data non ? compresa ed esce dal range.
*Nota: i parametri di ingresso sono tutte stringhe aventi il seguente formato: gg/mm/aaaa
*stringa sDataInizio: data di inizio range
*stringa sDataFine: data di fine range
*stringa sDataCompresa: data su cui effettuare il controllo
*booleano estremiCompresi: true se gli estremi sono compresi, false se non compresi
*/
function dataCompresa(sDataInizio, sDataFine, sDataCompresa, estremiCompresi){
	//Booleano che viene ritornato dalla funzione
	var dataIscompresa = true;
	//Converto in data tutte le stringhe ricevute in ingresso della funzione
	var DataInizio = new Date(parseInt(sDataInizio.substring(6, 10), 10), (parseInt(sDataInizio.substring(3, 5), 10)-1), parseInt(sDataInizio.substring(0, 2), 10));
	var DataFine = new Date(parseInt(sDataFine.substring(6, 10), 10), (parseInt(sDataFine.substring(3, 5), 10)-1), parseInt(sDataFine.substring(0, 2), 10));
	var DataCompresa = new Date(parseInt(sDataCompresa.substring(6, 10), 10), (parseInt(sDataCompresa.substring(3, 5), 10)-1), parseInt(sDataCompresa.substring(0, 2), 10));	
	//SE estremiCompresi = true
	//allora il controllo viene effettuato considerando anche gli estremi del range di date specificato
	if(estremiCompresi == true){
		//Data deve essere maggiore o uguale alla data di inizio
		if(DataCompresa.getTime() >= DataInizio.getTime()){
			//Data deve anche essere minore o uguale alla data di fine
			if(DataCompresa.getTime() <= DataFine.getTime()){
				dataIscompresa = true;
			}else{
				dataIscompresa = false;
			}
		}
	}else{
		//Data deve essere maggiore alla data di inizio
		if(DataCompresa.getTime() >= DataInizio.getTime()){
			//Data deve anche essere minore alla data di fine
			if(DataCompresa.getTime() <= DataFine.getTime()){
				dataIscompresa = true;
			}else{
				dataIscompresa = false;
			}
		}		
	}
	return dataIscompresa;
}

/*************************************************FINE MODIFICHE MICHELA 16/11/2004*****************************************************/


// Ritorna la data (sempre in formato GG/MM/AAAA) con l'aggiunta di tot giorni 
// (parametro Giorni) della data "ValoreData" passata come parametro nel formato GG/MM/AAAA
function AdiustDay(ValoreData, Giorni) {
	var ObjData=new Date(parseInt(ValoreData.substring(6, 10), 10), (parseInt(ValoreData.substring(3, 5), 10)-1), parseInt(ValoreData.substring(0, 2), 10));
	//alert("**DATA INIZIO: " + ObjData);
	
	//alert("Timezone prima: " + ObjData.getTimezoneOffset());
	
	var NuovaData = new Date(ObjData.getTime()+(Giorni*24*60*60*1000));
	//alert("Data milli: " + ObjData.getTime() + " Data inizio: " + new Date(ObjData.getTime()) );
	//alert("Variazione milli incremento: " + (Giorni*24*60*60*1000) + " Numero giorni da incrementare: " + Giorni + " Data fine: " + NuovaData);
	//alert("Timezone dopo: " + NuovaData.getTimezoneOffset());

	var iMinutiVariazione = ObjData.getTimezoneOffset() - NuovaData.getTimezoneOffset();
	
	if(Math.abs(iMinutiVariazione) > 0){
		if(iMinutiVariazione < 0){
			// Bisogna incrementare di un'ora
			NuovaData = new Date(NuovaData.getTime()+ (Math.abs(iMinutiVariazione)*60*1000));
		}else{
			// Bidogna decrementare di un'ora
			NuovaData = new Date(NuovaData.getTime()- (Math.abs(iMinutiVariazione)*60*1000));
		}
	}
	
	//alert("Data fine: " + NuovaData);
	
	
	var GG = '00' + NuovaData.getDate();
	GG = GG.substr(GG.length - 2);
	var mese = NuovaData.getMonth() +1;
	var MM = '00' + mese;
	MM = MM.substr(MM.length - 2)
	
	var anno = 0;
	
	if(document.all){
		anno = NuovaData.getYear();
	}else{
		anno = NuovaData.getYear() + 1900;
	}
	
	return GG + '/' + MM + '/' + anno;
}


/*
IN ORDINI
function completamentoAutomatico(evt, nomeForm, nomeCampo, vNomi){
		var cursorKeys ="8;46;37;38;39;40;33;34;35;36;45;";
		var bTrovato = false;
		//vengono ignorati alcuni tasti
		if (cursorKeys.indexOf(evt.keyCode+";") == -1) {
		
			var fForm = document.forms[nomeForm];
			var nome = fForm.elements[nomeCampo].value; //valore iniziale digitato
			var field = fForm.elements[nomeCampo];
			
			//For IE
			if (document.all) {
				if (field.createTextRange) {
					for(i = 0; i<vNomi.length; i++){
						nomeCorrente = vNomi[i];
						//Se il nome corrente presente sull'array iniza come il valore digitato nel campo di testo allora....
						if((((nomeCorrente.toLowerCase()).indexOf(nome.toLowerCase(),0)) == 0) && (bTrovato == false)){
							var r1 = field.createTextRange();
							var oldValue = r1.text;
							if(nomeCorrente != field.value){
								field.value = nomeCorrente;
								var rNew = field.createTextRange();
								rNew.moveStart('character', oldValue.length) ;
								rNew.select();
								bTrovato = true;
							}
						}//end if
					}//end for
				}//end if
			}//enf if IE
			//For Netscape, Mozilla
			else{
				
				if (typeof field.selectionStart != 'undefined') {
					if (evt.keyCode == 16) {
						return;
					}
					for(i = 0; i<vNomi.length; i++){
						nomeCorrente = vNomi[i];
						//Se il nome corrente presente sull'array iniza come il valore digitato nel campo di testo allora....
						if((((nomeCorrente.toLowerCase()).indexOf(nome.toLowerCase(),0)) == 0) && (bTrovato == false)){
							field.value = nomeCorrente;
							field.setSelectionRange(nome.length, field.value.length);
							bTrovato = true;
						}//end if
					}//end for
				}//end if
			}//end else Mozilla
			
		}//end if cursor
		
		return bTrovato;
		
}//end function
*/

















/*
Controlla (in base allo stile) se un gruppo di immagini/pulsanti (tutti con lo stesso nome)
sono abilitati o no. Restituisce il numero di pulsanti con il nome specificato che risultato
abilitati in base al loro stile attuale.
*/
function contaTastiAbilitati(nome) {
	// creo un array che contiene tutti gli elementi che hanno il nome (NAME o ID) specificato
	var elementiTrovati = document.all.item(nome);
	// 'trovati' indica quanti elementi risultano abilitati in base al foglio di stile
	var trovati = 0;
	
	if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
		// ho a che fare con un array; quindi sul documento sono presenti pi? elementi col nome specificato
		for (i = 0; i < elementiTrovati.length; i++) {
			if (elementiTrovati[i].className == "imgToolbarEnabled") trovati = trovati + 1;
		}
	} else {
		// ho trovato un unico elemento col nome specificato come parametro
		if (elementiTrovati.className == "imgToolbarEnabled") trovati = trovati + 1;
	}
	return trovati;
}


/*
Conta quanti elementi con il nome specificato sono presenti sul documento
*/
function contaTastiPresenti(nome) {
	var elementiTrovati = document.all.item(nome);
	if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
		// ho a che fare con un array di oggetti; restituisco la sua dimensione
		return elementiTrovati.length;
	} else {
		// ho a che fare con un unico oggetto (null se sul documento non ho trovato nessun elemento
		// col nome indicato)
		if ((elementiTrovati == null) || (elementiTrovati === undefined)) {
			return 0;
		} else {
			return 1;
		}
	}
}



/*
Funzione che abilita o disabilita un gruppo di pulsanti (immagini) con lo stesso nome.
Il primo parametro contiene il nome dei pulsanti da abilitare o disabilitare, il secondo
? true per abilitarli, false per disabilitarli.
*/
function abilitaTasti(nome, abilita) {
	var elementiTrovati = document.all.item(nome);
	var elementiTrovatiMoz = document.getElementById.item(nome);
	if (elementiTrovati != null) {
		if (abilita) {
			if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
				for (i = 0; i < elementiTrovati.length; i++) {
					elementiTrovati[i].className = "imgToolbarEnabled";
				}
			} else {
				// se passa per di qui non ho a che fare con un array ma con un singolo oggetto
				elementiTrovati.className = "imgToolbarEnabled";
			}
		} else {
			if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
				for (i = 0; i < elementiTrovati.length; i++) {
					elementiTrovati[i].className = "imgToolbarDisabled";		
				}
			} else {
				// se passa per di qui non ho a che fare con un array ma con un singolo oggetto
				elementiTrovati.className = "imgToolbarDisabled";
			}
		}
	}
}



/*
function validateDate(fld) {

    var mo, day, yr;
    var entry = fld.value;
    var reLong = /\b\d{1,2}[\/-]\d{1,2}[\/-]\d{4}\b/;
    var reShort = /\b\d{1,2}[\/-]\d{1,2}[\/-]\d{2}\b/;
    var valid = (reLong.test(entry)) || (reShort.test(entry));
    if (valid) {
        var delimChar = (entry.indexOf("/") != -1) ? "/" : "-";
        var delim1 = entry.indexOf(delimChar);
        var delim2 = entry.lastIndexOf(delimChar);
        day = parseInt(entry.substring(0, delim1), 10);
        mo = parseInt(entry.substring(delim1+1, delim2), 10);
        yr = parseInt(entry.substring(delim2+1), 10);
        // handle two-digit year
        if (yr < 100) {
            var today = new Date( );
            // get current century floor (e.g., 2000)
            var currCent = parseInt(today.getFullYear( ) / 100) * 100;
            // two digits up to this year + 15 expands to current century
            var threshold = (today.getFullYear( ) + 15) - currCent;
            if (yr > threshold) {
                yr += currCent - 100;
            } else {
                yr += currCent;
            }
        }
        var testDate = new Date(yr, mo-1, day);
        if (testDate.getDate( ) == day) {
            if (testDate.getMonth( ) + 1 == mo) {
                if (testDate.getFullYear( ) == yr) {
                    // fill field with database-friendly format
                    if (day<10) {
                    	day = "0" + day;
                    }
                    if (mo<10) {
                    	mo = "0" + mo;
                    }
                    fld.value = day + "/" + mo + "/" + yr;
                    return true;
                } else {
                    alert("L'anno inserito non ? corretto!");
                }
            } else {
                alert("Il mese inserito non ? corretto!");
            }
        } else {
            alert("Il giorno inserito non ? corretto!");
        }
    } else {
        alert("La data deve essere nel formato gg/mm/aaaa!");
    }
    return false;
}
*/

 
function abilitaGruppoTasti(fForm,array,abilita){
	if(document.all){
		for ( var indice = 0; indice < array.length; indice++ ) {
			var campo = fForm.elements[ array[indice] ];
			if(campo){
				if (abilita == true){
					campo.className="imgToolbarEnabled";
				}else{
					campo.className="imgToolbarDisabled";		
				}
			}
		}
	}else{
		for ( var indice = 0; indice < array.length; indice++ ) {
			element = document.getElementById(array[indice]);
			if(element){
				if (abilita == true){
					element.className="imgToolbarEnabled";
				}else{
					element.className="imgToolbarDisabled";		
				}
			}
		}
	}
}

/*
IN ATTICO 
	campo.className="imgToolbarEnabled";
	campo.disabled = false;

	campo.className="imgToolbarDisabled";	
	campo.disabled = true;	

	element.className="imgToolbarEnabled";
	element.disabled = false;
	
	element.className="imgToolbarDisabled";	
	element.disabled = true;	
*/



/*
* Funzione che ritorna true se un campo ? abilitato, false altrimenti.
*/
function campoAbilitato(nomeCampo){
	var classNameValue;
	if(document.all){
		classNameValue = document.all[ nomeCampo ].className;
	}else{
		classNameValue = document.getElementById( nomeCampo ).className;
	}	
	if(classNameValue == "inputReadOnly"){
		return false;
	}else{
		return true;
	}
}


/*
* Svuota tutti i campi text e input di un form ad eccezione
* di quelli specificati nell'array.
*/
function vuotaCampiNoArray(fForm, arrayNomi) {
		for (var indice = 0; indice < fForm.length; indice++) {
			var campo = fForm.elements[indice];
			if ((campo.type == "text") || (campo.type == "select-one")) {
				var bCancella = true;
				
				for(var x=0; x<arrayNomi.length; x++){
					if(campo.name == arrayNomi[x]){
						bCancella = false;
					}//if
				}//for
				
				if(bCancella == true){
					campo.value = "";
				}//if
			}//if
		}//for
	
	
}


/*
Mostra con un alert la stringa ricevuta come parametro.
Se la stringa ricevuta ? vuota, nulla o indefinita non mostra nessun alert.
*/
function visualizzaAlert(msg) {
	if ((msg != null) && (msg != undefined) && (msg != "")) {
		alert(msg);
	}
}


/*
Mostra o nasconde il <div> con l'id uguale al nome ricevuto come parametro
a seconda del secondo parametro, booleano, ricevuto (true per mostrare il div, false per nasconderlo)
*/
function mostraDiv(nomeDiv, mostra) {
	if (document.all) {
		if (mostra) {
			document.all[nomeDiv].style.display = "block";
		} else {
			document.all[nomeDiv].style.display = "none";
		}
	} else if(document.layers){
		if (mostra) {
			document.layers[nomeDiv].style.display = "block";
		} else {
			document.layers[nomeDiv].style.display = "none";
		}
	} else {
		if (mostra) {
			document.getElementById(nomeDiv).style.display = "block";
		} else {
			document.getElementById(nomeDiv).style.display = "none";
		}
	}
}


//Funzione utilizzata per abilitare o meno tutti i tasti/immagine che iniziano con una specifica stringa.
function abilitaTastiInizioNome(nomeIniziale, abilita){
	for (i=0; i<document.images.length;i++){
		var nomeImg = document.images[i].id;
		if(nomeImg.indexOf(nomeIniziale) != -1){
			abilitaImmagine(nomeImg, abilita);
		}
	}
}

//Funzione che abilita o disabilita un'immagine senza mettere la cornice all'immagine stessa
function abilitaImmagine(img,abilita){
	if ( abilita ){
		if(document.all){
			if (document.all[img] != null) {
				document.all[img].className = "imgEnabled";
			}
		}else{
			element = document.getElementById(img);
			if(element != null){
				element.className="imgEnabled";
			}
		}
	}else{
		if(document.all){
			if (document.all[img] != null) {
				document.all[img].className = "imgDisabled";		
			}
		}else{
			element = document.getElementById(img);
			if(element != null){
				element.className="imgDisabled";
			}
		}
	}
}

function openPopUpAttivita(URL, NomeFinestra, maximizza){

	var larghezza = 0, altezza = 0, margineTop = 0, margineLeft = 0;

	if(maximizza == "1"){
		larghezza = screen.availWidth-10;
		altezza = screen.availHeight-50;
		margineLeft = 0;
		margineTop = 0;
	}else{
		if (screen.availWidth >= 1000) {
			larghezza = 1000;
			
			margineLeft = (screen.availWidth - larghezza)/2;
		} else {
			larghezza = screen.availWidth;
		}
		
		if (screen.availHeight >= 670) {
			altezza = 670;
			
			margineTop = (screen.availHeight - altezza) / 2;
			if (margineTop >= 20) {
				margineTop -= 20;
			} else {
				margineTop = 0;
			}
		} else {
			altezza = screen.availHeight;
		}
	}
		
	//alert("status,alwayRaised,toolbar=no,location=no,scrollbars=yes,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + margineTop + ",left=" + margineLeft + ",fullscreen=" + full);
	var newFin = window.open(URL,NomeFinestra,"status,alwayRaised,toolbar=no,location=no,scrollbars=yes,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + margineTop + ",left=" + margineLeft,false);
	if (newFin != null) {
		newFin.focus();
	}
	
	return newFin;
}//openPopUp


function openPopUpCentrataNoScroll(URL, NomeFinestra, maximizza){

	var larghezza = 0, altezza = 0, margineTop = 0, margineLeft = 0;

	if(maximizza == "1"){
		larghezza = screen.availWidth-10;
		altezza = screen.availHeight-50;
		margineLeft = 0;
		margineTop = 0;
	}else{
		if (screen.availWidth >= 1000) {
			larghezza = 1000;
			
			margineLeft = (screen.availWidth - larghezza)/2;
		} else {
			larghezza = screen.availWidth;
		}
		
		if (screen.availHeight >= 670) {
			altezza = 670;
			
			margineTop = (screen.availHeight - altezza) / 2;
			if (margineTop >= 20) {
				margineTop -= 20;
			} else {
				margineTop = 0;
			}
		} else {
			altezza = screen.availHeight;
		}
	}
		
	//alert("status,alwayRaised,toolbar=no,location=no,scrollbars=yes,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + margineTop + ",left=" + margineLeft + ",fullscreen=" + full);
	var newFin = window.open(URL,NomeFinestra,"status,alwayRaised,toolbar=no,location=no,scrollbars=no,resizable=yes,width=" + larghezza + ",height=" + altezza + ",top=" + margineTop + ",left=" + margineLeft,false);
	if (newFin != null) {
		newFin.focus();
	}
	
	return newFin;
}//openPopUp

/*
Funzione che verifica se un'ora ? corretta (formato hh:mm:ss).
I parametri ricevuti corrispondono all'oggetto Form che contiene il campo di nome 'nomeCampo'
con l'ora da controllare.
Restituisce true se l'ora ? corretta, false altrimenti
Utilizzare questa funzione al posto di 'testOra()' che non supporta l'internazionalizzazione
*/
function verificaOra(fForm, nomeCampo) {
	var strdata = fForm.elements[nomeCampo].value;

	if (strdata == "") {
		return false;
	}
	if (strdata.length < 5) {
		if(strdata.substring(1,2) == ":"){
			strdata = "0" + strdata;
		}else{
			return false;
		}
	} 
	if (strdata.substring(2,3) != ":" ||
		strdata.substring(0,1) == "." ||
		strdata.substring(1,2) == "." ||
		strdata.substring(3,4) == "." ||
		strdata.substring(4,5) == "." ||
		isNaN(strdata.substring(0,2)) ||
		isNaN(strdata.substring(3,5))) {
		return false;
	}
	
	if ( (strdata.substring(0,2) > 23) || (strdata.substring(0,2) < 0) ) {
		return false;
	}
	if ( (strdata.substring(3,5) > 59) || (strdata.substring(3,5) < 0) ) {
		return false;
	}
	if ( (strdata.substring(6,8) > 59) || (strdata.substring(6,8) < 0) ) {
		return false;
	}
    return true;
}


function cambiaOrdineLayer(id, zIndex){
	document.getElementById(id).style.zIndex = zIndex;
}

  function addZero(vNumber){ 
    return ((vNumber < 10) ? "0" : "") + vNumber 
  } 
        
  function formatDate(vDate, vFormat){ 
    var vDay                      = addZero(vDate.getDate()); 
    var vMonth            = addZero(vDate.getMonth()+1); 
    var vYearLong         = addZero(vDate.getFullYear()); 
    var vYearShort        = addZero(vDate.getFullYear().toString().substring(3,4)); 
    var vYear             = (vFormat.indexOf("yyyy")>-1?vYearLong:vYearShort) 
    var vHour             = addZero(vDate.getHours()); 
    var vMinute           = addZero(vDate.getMinutes()); 
    var vSecond           = addZero(vDate.getSeconds()); 
    var vDateString       = vFormat.replace(/dd/g, vDay).replace(/MM/g, vMonth).replace(/y{1,4}/g, vYear) 
    vDateString           = vDateString.replace(/hh/g, vHour).replace(/mm/g, vMinute).replace(/ss/g, vSecond) 
    return vDateString 
  } 
 
 	
	//Funzione richiamata per disabilitare il default apertura popup "salva con nome"
	//durante la pressione dei tasti CTRL+S
	//Operazione effettuata solo per firefox
	function disattivaDefault(evt){
		if(!document.all){
			if(evt.ctrlKey == true){
				evt.stopPropagation();
				evt.preventDefault();
			}
		}
	}
	
	//Funzione che effettua il salvataggio in seguito alla pressione del tasto CTRL+S
	function controlloPressioneTastoSalva(evt){
		if(document.all){
			if(evt.ctrlKey == true && evt.keyCode == 83){
				salva();
			} 
		}else{
			if(evt.ctrlKey == true && evt.which == 83){
				salva();
			} 
		}
	}
	
	/*
	PIANO
	Funzione che abilita o disabilita un gruppo di pulsanti (immagini) con lo stesso nome.
	Il primo parametro contiene il nome dei pulsanti da abilitare o disabilitare, il secondo
	? true per abilitarli, false per disabilitarli.
	*/
	function abilitaImmagini(nome, abilita) {
		// estraggo dal documento tutti gli elementi col nome specificato
		
		var elementiTrovati = null;
		
		if(document.all){
			elementiTrovati = document.all.item(nome);
		}else{
			elementiTrovati = document.getElementById(nome);
		}
		
		if (elementiTrovati != null) {
		
		//alert("Recuperato elemento con nome: " + nome + " Abilita: " + abilita);
		
			if (abilita) {
				// sto abilitando tutti i pulsanti col nome specificato
				if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
					for (var i = 0; i < elementiTrovati.length; i++) {
						elementiTrovati[i].className = "imgEnabled";
					}
				} else {
					// se passa per di qui non ho a che fare con un array ma con un singolo oggetto
					elementiTrovati.className = "imgEnabled";
				}
			} else {
				// sto disabilitando tutti i pulsanti col nome specificato
				if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
					for (var i = 0; i < elementiTrovati.length; i++) {
						elementiTrovati[i].className = "imgDisabled";		
					}
				} else {
					// se passa per di qui non ho a che fare con un array ma con un singolo oggetto
					elementiTrovati.className = "imgDisabled";
				}
			}
		}
	}
	
	/*
	PIANO
	Abilita o disabilita le immagini i cui nomi vengono passati nell'array;
	le immagini vengono tutte abilitate se il secondo parametro ? true, disabilitate se ? false
	*/
	function abilitaImmaginiSpecifiche(array, abilita) {
		for (var i = 0; i < array.length; i++) {
			abilitaImmagini(array[i], abilita);
		}
	}
	
	/*
	PIANO
	Controlla (in base allo stile) se un gruppo di immagini/pulsanti (tutti con lo stesso nome)
	sono abilitati o no. Restituisce il numero di pulsanti con il nome specificato che risultato
	abilitati in base al loro stile attuale.
	*/
	function contaImmaginiAbilitate(nome) {
		// creo un array che contiene tutti gli elementi che hanno il nome (NAME o ID) specificato
		var elementiTrovati = document.all.item(nome);
		// 'trovati' indica quanti elementi risultano abilitati in base al foglio di stile
		var trovati = 0;
		
		if ((elementiTrovati.length !== undefined) && (elementiTrovati.length > 1)) {
			// ho a che fare con un array; quindi sul documento sono presenti pi? elementi col nome specificato
			for (var i = 0; i < elementiTrovati.length; i++) {
				if (elementiTrovati[i].className == "imgEnabled") trovati = trovati + 1;
			}
		} else {
			// ho trovato un unico elemento col nome specificato come parametro
			if (elementiTrovati.className == "imgEnabled") trovati = trovati + 1;
		}
		return trovati;
	}
	
	/*
	PIANO
	Apre una finestra di popup con il nome specificato, caricando l'URL ricevuto come parametro.
	La finestra aperta occupa circa met? schermo e viene posizionata sulla destra, in modo da
	risultare parzialmente sovrapposta alla finestra chiamante, come una guida in linea.
	*/
	function openHelpPopUp(URL, NomeFinestra) {
		var larghezza = screen.availWidth - 20;
		var altezza = screen.availHeight - 80;
		window.open(URL,NomeFinestra,"status,fullscreen=no,toolbar=no,location=no,scrollbars=yes,resizable=yes,width=" + (larghezza / 2) + ",height=" + altezza + ",top=5,left=" + (larghezza / 2),false);
	}
	
	/*
	PIANO
	Stessa funzione di svuotaCampiSpecifici, con l'aggiunta di un controllo
	preventivo sul fatto che sia abilitata l'immagine il cui nome viene
	ricevuto come parametro: i campi vengono svuotati solo se l'immagine ? 
	abilitata
	*/
	function controllaImgSvuotaCampiSpecifici(img, fForm, array) {
		if (! immagineAbilitata(img)) return;
		// se arriva a questo punto, l'immagine ? abilitata e svuoto i campi
		pulisciCampiSpecifici(fForm, array);
	}
	
	/*
	PIANO
	Abilita o disabilita i campi di una form.
	I parametri corrispondono al nome della form contenente i campi, ad un
	Array di stringhe con i nomi dei campi e ad un valore booleano per 
	specificare se abilitare (true) o disabilitare (false) tutti i campi indicati
	nell'Array
	*/
	function abilitaCampiSpecifici(fForm, array, abilita) {
		for ( var indice = 0; indice < array.length; indice++ ) {
			if ( fForm.elements[ array[indice] ] !== undefined &&
				fForm.elements[ array[indice] ] != null ) {
				var campo = fForm.elements[ array[indice] ];
				if ( campo.type == "text" || 
					 campo.type == "textarea" ||
					 campo.type == "password" ||
					 campo.type == "hidden" ) {
					campo.readOnly = !abilita;
					if ( abilita ) {
						campo.className ="inputWrite";
					} else {
						campo.className = "inputReadOnly";
					}
				} else if ( campo.type == "select-one" ||
							campo.type == "select-multiple" ) {
					campo.disabled = !abilita;
					if ( abilita ) {
						campo.className ="inputWriteSelect";
					} else {
						campo.className = "inputReadOnlySelectRadio";
					}
				} else if ( campo.type == "checkbox" ){
					campo.disabled = !abilita;
					if ( abilita ) {
						campo.className ="inputWriteTransparent";
					} else {
						campo.className = "inputReadOnlySelectRadio";
					}
				} else if(((campo[0]) && (campo[0].type == "radio")) || (campo.type == "radio")){
					if(campo.length != undefined){
						//Ci sono pi? pulsanti radio
						for(j=0; j<campo.length;j++){
							campo[j].disabled=!abilita;
							if ( abilita ) {
								campo[j].className ="inputWriteTransparent";
							} else {
								campo[j].className = "inputReadOnlySelectRadio";
							}
						}
					}else{
						//C'? solamente un pulsante radio
						campo.disabled=!abilita;
						if ( abilita ) {
							//campo.className ="inputWrite";
							campo[j].className ="inputWriteTransparent";
						} else {
							campo.className ="inputReadOnlySelectRadio";
							//campo.className = "inputWriteTransparent";
						}
					}
				}
			}
		}
	}
	
	/*
	PIANO
	Abilita o disabiilta un pulsante il cui nome viene passato come primo parametro
	a seconda che il secondo parametro (booleano) sia true (per abilitare) o false
	(per disabilitare)
	*/
	function abilitaPulsante(fForm, nomePulsante, abilita) {
		if (fForm.elements[nomePulsante] !== undefined && fForm.elements[nomePulsante] != null) {
			fForm.elements[nomePulsante].disabled = !abilita;
		}
	}
	
	
	/**
	 * Funzione che permette di verificare se un div ? visualizzato. Cio? se il div passato come parametro
	 * presenta come class show, in tale caso ritorna true.
	 */
	function verificaDivVisualizzato(nomeDiv){
		var nomeClass = "";
		
		if(document.all){
			nomeClass = document.all[nomeDiv].className;
		}else{
			nomeClass = document.getElementById(nomeDiv).className;
		}
		if(nomeClass == "show"){
			return true;
		}
		return false;
	}

	/**
	 * Funzione che permette di nascondere o visualizzare un div. Il primo parametro consiste nel nome
	 * del div e il secondo parametro bel booleano (true o false) che specifica se visualizzare o nascondere
	 * il div.
	 */
	function visualizzaNascondiDiv(nomeDiv, flagVisualizza){
		if(flagVisualizza == true){
			if(document.all){
				document.all[nomeDiv].className = "show";
			}else{
				document.getElementById(nomeDiv).className = "show";
			}
		}else{
			if(document.all){
				document.all[nomeDiv].className = "hide";
			}else{
				document.getElementById(nomeDiv).className = "hide";
			}
		}
	}
	
	
	/**
	 * Funzione che permette di verificare se un tr ? visualizzato. Cio? se il tr passato come parametro
	 * presenta come class showTr, in tale caso ritorna true.
	 */
	function verificaTrVisualizzato(idTr){
		var nomeClass = "";
		
		if(document.all){
			nomeClass = document.all[idTr].className;
		}else{
			nomeClass = document.getElementById(idTr).className;
		}
		if(nomeClass == "showTr"){
			return true;
		}
		return false;
	}
	
	/**
	 * Funzione che permette di nascondere o visualizzare una riga di una table. Il primo parametro consiste 
	 * nel nome del div e il secondo parametro bel booleano (true o false) che specifica se visualizzare 
	 * o nascondere il div.
	 */
	function visualizzaNascondiTr(nomeDiv, flagVisualizza){
		if(flagVisualizza == true){
			if(document.all){
				document.all[nomeDiv].className = "showTr";
			}else{
				document.getElementById(nomeDiv).className = "showTr";
			}
		}else{
			if(document.all){
				document.all[nomeDiv].className = "hideTr";
			}else{
				document.getElementById(nomeDiv).className = "hideTr";
			}
		}
	}