/******************************************************************************/
/*	Per poter utilizzare le funzioni incluse in questo file in intestazione 	*/
/*	di una pagina HTML deve essere incluso il seguente TAG:							*/
/*																										*/
/*					<HTML>																			*/
/*					<SCRIPT TYPE="Text/JavaScript"											*/
/*		  								LANGUAGE="JavaScript1.2"								*/
/*		  								SRC = "/ControlloDati/ControlloDati.js">			*/
/*																										*/
/******************************************************************************/

/******************************************************************************/
/*	 																									*/
/*	variabile globale per evitare i click multipli sul conferma						*/
/*	Per un esempio vedere jscriptList di un'anagrafica																									*/
/******************************************************************************/
var nclick=0;

/******************************************************************************/
/*	 																									*/
/*	Disabilita il tasto Invio per evitare problemi con l'onblur dei campi		*/
/*																										*/
/******************************************************************************/
/*
function disableInvio()
{
	if(event.keyCode==13){event.keyCode=0}
}
document.onkeypress=disableInvio;
*/

/******************************************************************************/
/*																										*/
/*	La funzione	"musterEnter(objName)" l'avvenuta valorizzazione					*/
/*	dell'oggetto in input.																		*/
/*																										*/
/* La chiamata a tale funzione in una pagina HTM deve essere eseguita			*/
/* in questa maniera:																			*/
/* <input type=text name=pippo NOME_EVENTO="musterEnter(this)">					*/
/*																										*/
/******************************************************************************/

/*  funzione che formatta una stringa data e aggiunge gli zeri se il giorno o il mese sono di lunghezza 1	*/
function dateFormat(data)
{
	var giorno = data.substring(0,data.indexOf("/"));
	var mese = data.substring(data.indexOf("/")+1,data.lastIndexOf("/"));
	var anno = data.substring(data.lastIndexOf("/")+1);
	if (giorno.lenght<1)
		giorno = "0" + giorno;
	if (mese.lenght<1)
		mese = "0" + mese;
	return giorno +"/"+ mese +"/"+ anno;
}

function mustEnterText(objName)
{
	if( objName.value == "" || objName.value == " " )
	{
		alert("Campo Obbligatorio.");
		objName.focus();
		objName.select();
		return false;
	}
	else
	{
		return true;
	}
}

function mustEnterCombo(objName)
{
	if( objName.selectedIndex ==0 || objName.selectedIndex ==-1)
	{
		//objName.select();
		alert("Campo Obbligatorio.");
		objName.focus();
		return false;
	}
	else
	{
		return true;
	}
}


function isNumberNoMust(objName)
{
	var appNum = objName.value;

	if(!(appNum==" "))
		return(isNumber(objName));

	return true;
}

function isNumber(objName)
{
	var appNum = objName.value;
	if(isNaN(appNum))
	{
		alert("Il campo può contenere solo valori numerici.");
		objName.focus();
		return false;
	}
	return true;
}

/******************************************************************************/
/*Controlla l'esattezza dell'anno che viene inserito in textbox

/******************************************************************************/

function controlloOra(objName)
{
	var time = objName.value;
	if (time.length!=5)
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	if (time.substring(2,3)!=":")
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	var hh = time.substring(0,2);
	if (hh.substring(0,1)=="0") hh = hh.substring(1,2);
	var intHH = parseInt(hh);
	if (isNaN(intHH))
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	if (intHH<0 || intHH>23)
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	var mm = time.substring(3,5);
	if (mm.substring(0,1)=="0") mm = mm.substring(1,2);
	if (isNaN(mm))
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	var intMM = parseInt(mm);
	if (intMM<0 || intMM>59)
	{
		alert("Formato ora non corretto.\n\nIl formato corretto è hh:mm");
		objName.focus();
		return false;
	}
	return true;
}

function ControlloDataAnno(objName)
{
	var datefield = objName;
	if (ControlloAnno(objName) == false)
	{
		datefield.select();
		alert("Anno non valido. Il formato corretto è: aaaa");
		datefield.focus();
		return false;
	}
	else
	{
		return true;
   }
}

function ControlloAnno(obj)
{
	if (obj.value.length == 0 || obj.value == " ")
	{
		return true;
	}
	if(isNaN(obj.value))
	{
  		return false;
	}
	else
	{
	   if(obj.value > 1900 && obj.value < 2100)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	return true;
}


/******************************************************************************/
/*																										*/
/*	La funzione	"ControlloDATA(objName)" controlla l'esattezza della DATA		*/
/*	passata all'interno dell'oggetto in input.											*/
/*																										*/
/* La chiamata a tale funzione in una pagina HTM deve essere eseguita			*/
/* in questa maniera:																			*/
/* <input type=text name=data onBlur=controlloDATA(this)>							*/
/*																										*/
/******************************************************************************/
function controlloDATA(objName)
{
	var datefield = objName;
	if (dataValida(objName) == false)
	{
		datefield.select();
		alert("Data non valida. Il formato corretto è: gg/mm/aaaa");
		datefield.focus();
		return false;
	}
	else
	{
		var oldData = objName.value;
		oldData=oldData.substring(6);

		if( parseInt(oldData) <= 1899 )
		{
			alert("La data inserita non può essere precedente al 1/1/1900");
			objName.focus();
			objName.select();
			return false;
		}
		return true;
   }
}

function dataValida(objName)
{
	var strDatestyle = "EU";  //European date style
	var strDate;
	var strDateArray;
	var strDay;
	var strMonth;
	var strYear;
	var intday;
	var intMonth;
	var intYear;
	var booFound = false;
	var datefield = objName;
	var strSeparatorArray = new Array("-"," ","/",".","\\");
	var intElementNr;
	var err = 0;
	strDate = datefield.value;

	if (strDate.length < 1)
	{
		return true;
	}

	//******************************
	//Aggiunta per DETE
	if (strDate == " ")
	{
		return true;
	}
	//*******************************/

	for (intElementNr = 0; intElementNr < strSeparatorArray.length; intElementNr++)
	{
		if (strDate.indexOf(strSeparatorArray[intElementNr]) != -1)
		{
			strDateArray = strDate.split(strSeparatorArray[intElementNr]);

			if (strDateArray.length != 3)
			{
				err = 1;
				return false;
			}
			else
			{
				strDay = strDateArray[0];
				strMonth = strDateArray[1];
				strYear = strDateArray[2];
			}
			booFound = true;
   	}
	}

	//Solo quando non è inserito neanche una volta un elemento separatore
	if (booFound == false)
	{
		//if (strDate.length>5)
		if (strDate.length == 8)
		{
			strDay = strDate.substr(0, 2);
			strMonth = strDate.substr(2, 2);
			strYear = strDate.substr(4);
   	}
	}

	//Controllo che nel campo relativo ai GIORNI
	//sia stato inserito	un valore numerico
	if (isNaN(strDay))
	{
		err = 2;
		return false;
	}
	intday = parseInt(strDay, 10);

	//Controllo che nel campo relativo al MESE
	//sia stato inserito	un valore numerico
	if (isNaN(strMonth))
	{
   	err = 3;
		return false;
	}
	intMonth = parseInt(strMonth, 10);

	//Controllo che nel campo relativo all'ANNO
	//sia stato inserito	un valore numerico
	if (isNaN(strYear) || strYear.length != 4)
	{
		err = 4;
		return false;
	}
	intYear = parseInt(strYear, 10);

	//Verifico che sia stato inserito un MESE valido
	if (intMonth>12 || intMonth<1)
	{
		err = 5;
		return false;
	}

	//Verifico che sia stato inserito un GIORNO valido
	//per i mesi che hanno massimo 31 giorni
	if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intday > 31 || intday < 1))
	{
		err = 6;
		return false;
	}

	//Verifico che sia stato inserito un GIORNO valido
	//per i mesi che hanno massimo 30 giorni
	if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intday > 30 || intday < 1))
	{
		err = 7;
		return false;
	}

	//Verifico che sia stato inserito
	//un GIORNO valido per il mese di FEBBRAIO
	if (intMonth == 2)
	{
		if (intday < 1)
		{
			err = 8;
			return false;
		}
		if (annoBisestile(intYear) == true)
		{
			if (intday > 29)
			{
				err = 9;
				return false;
			}
		}
		else
		{
			if (intday > 28)
			{
				err = 10;
				return false;
			}
		}
	}

	if (strDatestyle == "EU")
	{
		if(intday<10)
		{
			if(intMonth<10)
			{
				datefield.value = "0" + intday + "/0" + intMonth + "/" + strYear;
			}
			else
			{
				datefield.value = "0" + intday + "/" + intMonth + "/" + strYear;
			}
		}
		else
		{
			if(intMonth<10)
			{
				datefield.value = intday + "/0" + intMonth + "/" + strYear;
			}
			else
			{
				datefield.value = intday + "/" + intMonth + "/" + strYear;
			}
		}
	}

	return true;
}

//La funzione controlla se il valore numerico relativo
//all'ANNO inserito corrisponde ad un anno BISESTILE o meno
//Se è BISESTILE ritorna true se no false
function annoBisestile(intYear)
{
	if (intYear % 100 == 0)
	{
		if (intYear % 400 == 0)
		{
			return true;
		}
	}
	else
	{
		if ((intYear % 4) == 0)
		{
			return true;
		}
	}

	return false;
}

function consecutioDateOk(from, to)
{

    var dayFrom=from.value.substring(0,2);
    var monthFrom=from.value.substring(3,5);
    var yearFrom=from.value.substring(6);

    var dayTo=to.value.substring(0,2);
    var monthTo=to.value.substring(3,5);
    var yearTo=to.value.substring(6);

    if (from.value.substring(0,1)=='0')
    {
    	dayFrom=from.value.substring(1,2);
	 }

	 if (to.value.substring(0,1)=='0')
    {
    	dayTo=to.value.substring(1,2);
	 }

	 if (from.value.substring(3,4)=='0')
    {
    	monthFrom=from.value.substring(4,5);
	 }

	 if (to.value.substring(3,4)=='0')
    {
    	monthTo=to.value.substring(4,5);
	 }

   if(parseInt(yearFrom) > parseInt(yearTo))
   {
	alert("La seconda data non può essere antecedente alla prima.");
	//	alert("Anno non valido");
		return false;
   }
	else if(parseInt(yearFrom) == parseInt(yearTo))
	{
		if(parseInt(monthFrom) > parseInt(monthTo))
		{
    		//alert("Mese non valido");
    		alert("La seconda data non può essere antecedente alla prima.");
    		return false;
		}
		else if(parseInt(monthFrom) == parseInt(monthTo))
		{
			if(parseInt(dayFrom) > parseInt(dayTo))
			{
				//alert("Giorno non valido DA: "+parseInt(dayFrom)+" A: "+parseInt(dayTo)+"@");
				alert("La seconda data non può essere antecedente alla prima.");
				return false;
			}
		}
	}
   return true;
}



function consecutioDate(from, to)
{
	alert(from.value);
	alert(to.value);
      alert(Date.parse(from.value));
      alert(Date.parse(to.value));

	var da = Date.parse(from);
	var a = Date.parse(to);

	if (da <= a)
	{
		alert("Le date sono valide.");
		return true;
	}
	else
	{
		if (from == "" || to == "")
			return true; //alert("Inserire entrambe le date.");
		else
			alert("La seconda data non puo essere antecedente alla prima.");

		return false;
   }
}

/******************************************************************************/
/*																										*/
/*	La funzione	"formattaLire(objName)" formatta una stringa numerica				*/
/*	secondo lo standard  relativo alla moneta ITALIANA (LIRA).						*/
/*	In caso di errore o di caratteri non numerici il valore viene					*/
/* impostato a "L. 0"																			*/
/*																										*/
/* La chiamata a tale funzione in una pagina HTM deve essere eseguita			*/
/* in questa maniera:																			*/
/* <input type=text name=MONETA onBlur=this.form.MONETA.value=formattaLire(this);>*/
/*																										*/
/******************************************************************************/
function formattaLire(objNumber)
{

	//Recupero del valore non formattato
	//var num = eliminaFormattazioneLire(objNumber);
	var num = objNumber.value;

	//Recupero valore assoluto per spazi inziali o finali
	num = Math.floor(num).toString();


	//Formattazione Corretta del numero
	for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
		num = num.substring(0,num.length-(4*i+3))
				+'.'
				+num.substring(num.length-(4*i+3));

	//Ritorno del parametro corretto e formattato
	//objNumber.value = 'L. ' + num;
	////////////////////////return ('L. ' + num);
	if(num.charAt(0) == '-'  && num.charAt(1) == '.')
	{
		num = num.charAt(0) + num.substring(2,num.length);
	}
	return (num);
}

function eliminaFormattazioneLire(objNumber)
{
	//Recupero del valore
	var num = objNumber.value;

	num = num.toString().replace(/\ /g,'');

	//Eliminazione del simbolo della Lira
	indexSearch = -1;
	indexSearch = num.search(/L\./);
	if(indexSearch == 0)
	{
		num = num.replace(/L\./,'');
	}
	else
	{
		indexSearch = num.search(/L/);
		if(indexSearch == 0)
		{
			num = num.toString().replace(/\L/,'');
		}
	}

	num = num.toString().replace(/\./g,'');

	//Verifica che il paramentro sia numerico
	if(isNaN(num))
		return false;

	//Assegnazione del valore non formattato
	objNumber.value = num;

	return true;
}

/******************************************************************************/
/*																										*/
/*	La funzione	"EuroToLire(euro1, local1)" converte il valore passato nel		*/
/*	primo parametro (euro1) nell'equivalente in lira Italiana e lo inserisce	*/
/*	nel secondo parametro (local1).															*/
/*	Inoltre la funzione si proccupa di formattare il primo parametro in base	*/
/*	allo standard della MONETA EUROPEA (EURO) ed il secondo parametro in base	*/
/*	allo standard della MONETA ITALIANA (LIRA).											*/
/*	In caso di errore o di caratteri non numerici i valori verranno				*/
/* impostati rispettivamente a "E. 0,00" ed "L. 0".									*/
/*																										*/
/* La chiamata a tale funzione in una pagina HTM deve essere eseguita			*/
/* in questa maniera:																			*/
/*	<INPUT onBlur=EuroToLire(this.form.EURO,this.form.LOCAL) name=EURO size=8>	*/
/*																										*/
/******************************************************************************/

var rate = 1936.27;
var impUtenteEuro;
var impUtenteLire;
var flagOK = false;

function EuroToLire(euro1, local1, appoEuro, appoLire)
{

	//Verifico che non sia nullo
	if (euro1.value != "")
	{
		//Salvataggio del valore immesso dall'utente
		impUtenteEuro = euro1.value;

		//Recupero del valore pulito
		//euro1.value = eliminaFormattazioneEuro(euro1);
		flagOK = eliminaFormattazioneEuro(euro1);

		if(!flagOK)
		{
			euro1.value = impUtenteEuro;
			alert("Errore nell'inserimento Importo in EURO");
			euro1.value ='0,00';
			euro1.select();
			euro1.focus();

			return false;
		}

		//Tronco il numero ai centesimi di Euro
		//euro1.value = troncaAiCentesimi(euro1.value);
		//euro1.value = arrotondaCentesimi(euro1.value);

		//alert("appoEuro_OLD = "+appoEuro.value);
		//alert("euro1.value = "+euro1.value );
		if( appoEuro.value == "" && (euro1.value == 0 || euro1.value == 0.00 || euro1.value == 0.0000) )
		{
			local1.value = "0";
			appoEuro.value = "0.000";
			appoLire.value = "0";
		}

		if(euro1.value=="0.00" || euro1.value =="0")
		 local1.value=0;



		if(parseFloat(arrotondaCentesimi(euro1.value)) != parseFloat(arrotondaCentesimi(appoEuro.value)))
		{
			euro1.value = arrotondaMillesimi(euro1.value);
			appoEuro.value = euro1.value;

			//Calcolo dell'equivalente in LIRE
			local1.value = eval(euro1.value * rate);

			//Arrotondamento alle parte intera
			//relativa dell'importo in Lire
			local1.value=eval(Math.round(local1.value));

			euro1.value = arrotondaCentesimi(euro1.value);

			//Impostazione dei valori nei campi di appoggio
			appoLire.value = local1.value;

			//alert("appoEuro = "+appoEuro.value);
			//alert("appoLire = "+appoLire.value);

			//Presentazione degli importi
			//in formato corretto
			local1.value=formattaLire(local1);
			euro1.value = formattaEuro(euro1);
		}
		else
		{
			euro1.value = arrotondaCentesimi(euro1.value);
			euro1.value = formattaEuro(euro1);
		}
	}
	else
	{
		local1.value = "";
		appoEuro.value = "";
		appoLire.value = "";
	}

	return true;
}

/******************************************************************************/
/*																										*/
/*	La funzione	"LireToEuro(local2, euro2)" converte il valore passato nel		*/
/*	primo parametro (local2) nell'equivalente in moneta Europea e lo inserisce	*/
/*	nel secondo parametro (euro2).															*/
/*	Inoltre la funzione si proccupa di formattare il primo parametro in base	*/
/*	allo standard della MONETA ITALIANA (LIRA) ed il secondo parametro in base	*/
/*	allo standard della  MONETA EUROPEA (EURO).											*/
/*	In caso di errore o di caratteri non numerici i valori verranno				*/
/* impostati rispettivamente a "L. 0" ed "E. 0,00".									*/
/*																										*/
/* La chiamata a tale funzione in una pagina HTM deve essere eseguita			*/
/* in questa maniera:																			*/
/*	<INPUT onBlur="LireToEuro(this.form.LOCAL, this.form.EURO)" name=LOCAL >	*/
/*																										*/
/******************************************************************************/
function LireToEuro(local2, euro2, appoLire, appoEuro)
{
	//Verifico che non sia nullo
	if (local2.value != "")
	{
		//Salvataggio del valore immesso dall'utente
		impUtenteLire = local2.value;

		//Recupero valore pulito
		flagOK = eliminaFormattazioneLire(local2);

		if(!flagOK)
		{
			local2.value = impUtenteLire;
			alert("Errore nell'inserimento Importo in LIRE");
			local2.value ='0';
			local2.select();
			local2.focus();



			return false;
		}

		if(parseInt(local2.value) != parseInt(appoLire.value))
		{
			//Calcolo l'equivalente in EURO
			euro2.value = eval(local2.value / rate);

			euro2.value = arrotondaMillesimi(euro2.value);

			appoLire.value = local2.value;
			appoEuro.value = euro2.value;

			euro2.value = arrotondaCentesimi(euro2.value);


			//alert("appoLire = "+appoLire.value);
			//alert("appoEuro = "+appoEuro.value);

			local2.value = formattaLire(local2);
			euro2.value = formattaEuro(euro2);
		}
		else
		{
			local2.value = formattaLire(local2);
		}
	}
	else
	{
		euro2.value = "";
		appoLire.value = "";
		appoEuro.value = "";
	}

	return true;
}


function eliminaFormattazioneEuro(objNumber)
{
	var strSeparator = ",";

	//Recupero del valore
	var num = objNumber.value;

	num = num.toString().replace(/\ /g,'');
	//Eliminazione del simbolo dell'euro
	indexSearch = -1;
	indexSearch = num.search(/€\./);
	if(indexSearch == 0)
	{
		//alert("EEEEEEEEE ="+indexSearch);
		num = num.replace(/€\./,'');
	}
	else
	{
		indexSearch = num.search(/€/);
		if(indexSearch == 0)
		{
			num = num.toString().replace(/\€/,'');
		}
	}

	num = num.toString().replace(/\./g,'');

	//Se la stringa CONTIENE il carattere della VIRGOLA
	//la considero formattata quindi i PUNTI sono interpretati
	//come RAGGRUPPATORI DI MIGLIAIA.
	if (num.indexOf(strSeparator) != -1)
	{
		//Eliminazione dei caratteri speciali
		//num = num.toString().replace(/\€|\.|\ /g,'');
		//num = num.toString().replace(/\./g,'');

		//alert("NUM NUM NUM ="+num);

		//Sostituzione della prima VIRGOLA con il PUNTO
		num = num.toString().replace(/\,/,'.');
		//Eliminazione di altre eventuali VIRGOLE irregolari
		num = num.toString().replace(/\,/g,'');
	}
	//Altrimenti la considero come un valore
	//assoluto ed il primo PUNTO viene considerato
	//come SEPARATORE DECIMALE.
	else
	{
		//num = num.toString().replace(/\€.|\€|\.|\ /g,'');
		/*
		//Eliminazione dei caratteri speciali
		num = num.toString().replace(/\€.|\€|\ /g,'');
		//Sostituzione del primo PUNTO con la VIRGOLA
		num = num.toString().replace(/\./,',');
		//Eliminazione di altri eventuali PUNTI irregolari
		num = num.toString().replace(/\./g,'');
		//Ricollocazione del PUNTO come SEPARATORE DECIMALE
		num = num.toString().replace(/\,/,'.');
		*/
	}

	//Verifica che il paramentro sia numerico
	if(isNaN(num))
		return false;

	//Assegnazione del valore non formattato
	objNumber.value = num;

	return true;
}


function formattaEuro(objNumber)
{
	num = new String();
	var strSeparatorArray = new Array(".","\,");

	//Recupero del valore
	//num = eliminaFormattazioneEuro(objNumber);
	num = objNumber.value;

	//Arrotondamento ai centesimi di Euro
	//ossia alle due cifre decimali
	num = arrotondaCentesimi(num);
	/*var valoreNumerico = num;
	valoreNumerico = eval(Math.round(valoreNumerico * 100)) / 100;
	num = valoreNumerico.toString();
	*/

	//Verifico se il numero ha una componente decimale
	index = num.indexOf(strSeparatorArray[0]);
	if (index < 0)
	{
		//Formattazione Corretta del numero
		for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
			num = num.substring(0,num.length-(4*i+3))
					+'.'
					+num.substring(num.length-(4*i+3));

		num = num + ",00";

		//objNumber.value = '€. ' + num;
		/////////////////////////////////////////num = '€. ' + num;

	}
	else
	{
		//Recupero la parte intera del numero
		beforeComma = num.substring(0, index);

		//Formattazione Corretta della parte intera del numero
		for (var i = 0; i < Math.floor((beforeComma.length-(1+i))/3); i++)
			beforeComma = beforeComma.substring(0,beforeComma.length-(4*i+3))
					+'.'
					+beforeComma.substring(beforeComma.length-(4*i+3));

		num = num.substring(0, index + 3);

		//Inserimento della virgola ed aggiunta
		//della parte decimale al numero
		if (num.length < (index + 3))
		{
			if(num.length < (index + 2))
			{
				//objNumber.value = "€. " + beforeComma + ",00";
				/////////////////////////////num = "€. " + beforeComma + ",00";
				num = beforeComma + ",00";
			}
			else
			{
				//objNumber.value = "€. " + beforeComma + strSeparatorArray[1] + num.substring(index+1, index+2) + "0";
				//////////////////////////////////num = "€. " + beforeComma
				//////////////////////////////////				+ strSeparatorArray[1]
				//////////////////////////////////				+ num.substring(index+1, index+2)
				//////////////////////////////////				+ "0";

				num = beforeComma
						+ strSeparatorArray[1]
						+ num.substring(index+1, index+2)
						+ "0";
			}

		}
		else
		{
			//objNumber.value = "€. " + beforeComma + strSeparatorArray[1] + num.substring(index+1, index+3);
			//////////////////////////////////num = "€. " + beforeComma
			//////////////////////////////////				+ strSeparatorArray[1]
			//////////////////////////////////				+ num.substring(index+1, index+3);

			num = beforeComma
						+ strSeparatorArray[1]
						+ num.substring(index+1, index+3);
		}
	}

	if(num.charAt(0) == '-'  && num.charAt(1) == '.')
	{
		num = num.charAt(0) + num.substring(2,num.length);
	}

	return (num);
}

/******************************************************************************/
/*																										*/
/*	La funzione	"arrotondaCentesimi(varNumber)" consente di tornire(arrotondare)*/
/* un valore decimale ai Centesimi.															*/
/*																										*/
/*	Es:	varNumber = 125.25896....  ritorna --> 125.26								*/
/*			varNumber = 125.25432....  ritorna --> 125.25								*/
/*			varNumber = 125.5  			ritorna --> 125.50								*/
/*			varNumber = 125.				ritorna --> 125.00								*/
/* 		varNumber = 125				ritorna --> 125.00								*/
/*			varNumber = non è numero	ritorna --> 0.00									*/
/*																										*/
/******************************************************************************/
function arrotondaCentesimi(varNumber)
{
	//Verifico che suia un numero
	if (isNaN(varNumber))
	{
		return ("0.00");
	}

	//Arrotondamento alle due cifre decimali
	var valoreNumerico = varNumber;
	valoreNumerico = eval(Math.round(valoreNumerico * 100)) / 100;


	//Verifico se il numero ha una componente decimale
	varNumber = valoreNumerico.toString();

	index = varNumber.indexOf(".");
	if (index < 0)
	{
		varNumber = varNumber + ".00";
	}
	else
	{
		//Recupero la parte intera del numero
		beforeComma = varNumber.substring(0, index);

		varNumber = varNumber.substring(0, index + 3);

		//Inserimento della virgola ed aggiunta
		//della parte decimale al numero
		if (varNumber.length < (index + 3))
		{
			if(varNumber.length < (index + 2))
			{
				varNumber = beforeComma + ".00";
			}
			else
			{
				varNumber = beforeComma + "." + varNumber.substring(index+1, index+2) + "0";
			}

		}
		else
		{
			varNumber = beforeComma + "." + varNumber.substring(index+1, index+3);
		}
	}

	return(varNumber);
}


/******************************************************************************/
/*																										*/
/*	La funzione	"troncaAiCentesimi(varNumber)" consente di troncare un numero	*/
/* avente n posiszioni decimali ai Centesimi.											*/
/*																										*/
/*	Es:	varNumber = 136.25896....  ritorna --> 136.25								*/
/*			varNumber = 136.25432....  ritorna --> 136.25								*/
/*			varNumber = 136.5  			ritorna --> 136.50								*/
/*			varNumber = 136.				ritorna --> 136.00								*/
/* 		varNumber = 136				ritorna --> 136.00								*/
/*			varNumber = non è numero	ritorna --> 0.00									*/
/*																										*/
/******************************************************************************/
function troncaAiCentesimi(varNumber)
{
	//Verifico che sia un valore numerico
	if (isNaN(varNumber))
	{
		//alert("Tronca NULLO");
		return ("0.00");
	}

	index = varNumber.indexOf(".");
	if (index < 0)
	{
		//alert("Tronca minore 0");
		varNumber = varNumber + ".00";
	}
	else
	{
		//alert("Tronca else");
		//Recupero la parte intera del numero
		beforeComma = varNumber.substring(0, index);

		varNumber = varNumber.substring(0, index + 3);

		//Inserimento della virgola ed aggiunta
		//della parte decimale al numero
		if (varNumber.length < (index + 3))
		{
			if(varNumber.length < (index + 2))
			{
				varNumber = beforeComma + ".00";
			}
			else
			{
				varNumber = beforeComma + "." + varNumber.substring(index+1, index+2) + "0";
			}

		}
		else
		{
			varNumber = beforeComma + "." + varNumber.substring(index+1, index+3);
		}
	}

	return(varNumber);
}


function arrotondaMillesimi(varNumber)
{
	//Verifico che suia un numero
	if (isNaN(varNumber))
	{
		return ("0.00");
	}

	//Arrotondamento alle due cifre decimali
	var valoreNumerico = varNumber;
	valoreNumerico = eval(Math.round(valoreNumerico * 10000)) / 10000;


	//Verifico se il numero ha una componente decimale
	varNumber = valoreNumerico.toString();

	index = varNumber.indexOf(".");
	if (index < 0)
	{
		varNumber = varNumber + ".0000";
	}
	else
	{
		//Recupero la parte intera del numero
		beforeComma = varNumber.substring(0, index);

		varNumber = varNumber.substring(0, index + 5);

		//Inserimento della virgola ed aggiunta
		//della parte decimale al numero
		if (varNumber.length < (index + 5))
		{
			if(varNumber.length < (index + 2))
			{
				varNumber = beforeComma + ".0000";
			}
			else if(varNumber.length < (index + 3))
			{
				varNumber = beforeComma + "." + varNumber.substring(index+1, index+3) + "000";
			}
			else if(varNumber.length < (index + 4))
			{
				varNumber = beforeComma + "." +  varNumber.substring(index+1, index+4) +"00";
			}
			else
			{
				varNumber = beforeComma + "." + varNumber.substring(index+1, index+5) + "0";
			}

		}
		else
		{
			varNumber = beforeComma + "." + varNumber.substring(index+1, index+5);
		}
	}


	return(varNumber);
}

/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
function EuroToLireInit(appoEuro, appoLire, euro1, local1)
{
	//Verifico che non sia nullo

	if (appoEuro.value != "")
	{
		//Calcolo dell'equivalente in LIRE
		local1.value = eval(appoEuro.value * rate);



		//Arrotondamento alle parte intera
		//relativa dell'importo in Lire
		local1.value=eval(Math.round(local1.value));

		appoLire.value=local1.value;



		euro1.value = arrotondaCentesimi(appoEuro.value);

		//Presentazione degli importi
		//in formato corretto
		local1.value=formattaLire(local1);

		euro1.value = formattaEuro(euro1);


	}
	else
	{
		local1.value = "";
		appoEuro.value = "";
		appoLire.value = "";
	}

	return true;
}


/******************************************************************************/
/*																										*/
/*	La funzione	"checkPartitaIva(objPiva)" verifica se									*/
/* il parametro passato in input sia una PARTITA IVA corretta.						*/
/*																										*/
/*	Ritorna TRUE se è una partita IVA corretta altrimenti ritorna FALSE.			*/
/*																										*/
/******************************************************************************/
function checkPartitaIva(objPiva)
{
	var cf = objPiva.value;

	if( (cf != "") && (cf != " "))
	{
		if (isDigit(cf.charCodeAt(0)))
		{ //codice fiscale per persona giuritica (numerico)
			if ( cf.length != 11 )
			{
				objPiva.select();
				alert("Il codice della partita IVA deve avere una lunghezza di 11 caratteri.");
				objPiva.focus();
				return false;
			}
			var t = 0;
			var index = 0;
			var even = 0;
			for (var i = 1; i < 11; i++ )
			{
				if (!isDigit(cf.charCodeAt(i-1)) )
				{
					objPiva.select();
					alert("E' stato inserito un carattere non valido");
					objPiva.focus();
					return false;
				}
				even  = parseInt(( i / 2 ),10) * 2;
				index = parseInt(cf.charAt(i-1),10);

				if ( even == i )
				{
					var u = index * 2;
					if (u > 9)
					{
						var pp = u+"";
						u = parseInt(pp.charAt(0),10) + parseInt(pp.charAt(1),10);
					}
					t += u;
				}
				else
				{
					t += index;
				}
			}
			var ff = t +"";
			t = 10 - parseInt(ff.charAt(1),10);
			if ( parseInt(cf.charAt(10)) != t )
			{
				objPiva.select();
				alert("Il codice della partita IVA inserito non è corretto!");
				objPiva.focus();
				return false;
			}
		}
	}
	return true;
}

/******************************************************************************/
/*																										*/
/*	La funzione	"correctCharacters( textToCheck )" verifica se  					*/
/* il parametro passato in input non abbia caratteri diversi dalle 				*/
/*	lettere maiuscole e minuscole e dalle cifre da 0 a 9.								*/
/*	Ritorna TRUE se è un codice pulito altrimenti ritorna FALSE.					*/
/*																										*/
/******************************************************************************/
function correctCharacters( objText )
{
	var textToCheck = objText.value;

	for (var i = 0; i < textToCheck.length; i++ )
	{
		if (!isLetterOrDigit(textToCheck.charCodeAt(i)) )
		{
			objText.select();
			alert("E' stato inserito un carattere non valido");
			objText.focus();
			return false;
		}

	}
	return true;
}

/******************************************************************************/
/*	La funzione check mail, verifica che nell'indirizzo e-mail scritto																									*/
/*	dall'utente siano presenti i caratteri "@" e "."																									*/
/******************************************************************************/
function checkMail( mail )
{
	var email = new String(mail.value);
	if( email.indexOf("@")==-1 || email.indexOf(".")==-1)
	{
		mail.select();
		alert("L'indirizzo inserito non è valido.");
		mail.focus();
		return false;

	}
	return true;
}




/******************************************************************************/
/*																										*/
/*	La funzione	"checkCodFiscale( objCodFisc )" verifica se  						*/
/* il parametro passato in input sia un CODICE FISCALE corretto.					*/
/*																										*/
/*	Ritorna TRUE se è un codice corretto altrimenti ritorna FALSE.					*/
/*																										*/
/******************************************************************************/
function checkCodFiscale( objCodFisc )
{
	var cf = objCodFisc.value;
	cf = cf.toUpperCase();
	if( cf != "" && cf != " ")
	{

		if (!isDigit(cf.charCodeAt(0)))
		{//codice fiscale per persona fisica
			if ( cf.length != 16 )
			{
				objCodFisc.select();
				alert("Il Codice Fiscale deve avere una lunghezza di 16 caratteri.");
				objCodFisc.focus();
				return false;
			}
			valori = new Array(26)
			valori[0]  = 1
			valori[1]  = 0
			valori[2]  = 5
			valori[3]  = 7
			valori[4]  = 9
			valori[5]  = 13
			valori[6]  = 15
			valori[7]  = 17
			valori[8]  = 19
			valori[9]  = 21
			valori[10] = 2
			valori[11] = 4
			valori[12] = 18
			valori[13] = 20
			valori[14] = 11
			valori[15] = 3
			valori[16] = 6
			valori[17] = 8
			valori[18] = 12
			valori[19] = 14
			valori[20] = 16
			valori[21] = 10
			valori[22] = 22
			valori[23] = 25
			valori[24] = 24
			valori[25] = 23

			var t = 0;
			var index = 0;
			var even = 0;
			for (var i = 1; i < 16; i++ )
			{
				if (!isLetterOrDigit(cf.charCodeAt(i-1)) )
				{
					objCodFisc.select();
					alert("E' stato inserito un carattere non valido");
					objCodFisc.focus();
					return false;
				}
				even  = parseInt(( i / 2 ),10) * 2;
				index = cf.charCodeAt(i-1);
				if ( index > 60 )
					index -= 65;
				else
					index -= 48;
				if ( even == i )
					t = t + index;
				else
					t = t + parseInt(valori[index]);
			}
		}
		t = t - parseInt( t / 26,10 ) * 26 + 65;
		if ( cf.charCodeAt(15) != t )
		{
			objCodFisc.select();
			alert("Il codice fiscale inserito non è corretto!");
			objCodFisc.focus();
			return false;
		}
	}
	return true;
}

/******************************************************************************/
/*																										*/
/*	La funzione	"isLetterOrDigit(myCodChar)" consente di verificare se  			*/
/* il parametro passato in input sia un numero o un carattere generico validi.*/
/*																										*/
/*	Ritorna TRUE se l'input è un numero o una lettera dell'alfabeto,				*/
/* altrimenti torna FALSE.																		*/
/*																										*/
/******************************************************************************/
function isLetterOrDigit(myCodChar)
{
	if ( (parseInt(myCodChar)>=48) && (parseInt(myCodChar)<=57) || (parseInt(myCodChar)>=65) && (parseInt(myCodChar)<=90) || (parseInt(myCodChar)>=97) && (parseInt(myCodChar)<=122))
	{
		return true;
	}
	else
	{
		return false;
	}
}

/******************************************************************************/
/*																										*/
/*	La funzione	"isDigit(myCodChar)" consente di verificare se il parametro		*/
/* passato in input sia un numero.															*/
/*																										*/
/*	Ritorna TRUE se l'input è un numero altrimenti torna FALSE.						*/
/*																										*/
/******************************************************************************/
function isDigit(myCodChar)
{
	if ( (parseInt(myCodChar)>=48) && (parseInt(myCodChar)<=57) )
	{
		return true;
	}
	else
	{
		return false;
	}
}

/******************************************************************************/
/*																										*/
/*	La funzione	"checkOra(object)" verifica se il textfield passato in input 	*/
/* contiene un'ora che rispetta il seguente formato:									*/
/*		  		hh:mm || hh.mm				es. 10:30 || 10.30								*/
/*																										*/
/*	Ritorna TRUE se l'ora inserita rispetta il formato altrimenti torna FALSE.	*/
/*																										*/
/******************************************************************************/
function checkOra(obj){
	var ora = obj.value;
	var strOra = new String(ora);
	var len = strOra.length;

	//alert("Stringa: "+ strOra);
	//alert("Lunghezza: " + len);
   if(len > 0 && strOra != " "){
		if(len == 4)
			strOra = "0" + strOra;
		if(len < 4){
			alert("Ora non valida");
			obj.focus();
			obj.select();
			return false;
		}

		var hour   = strOra.substring(0,2);
		var minute = strOra.substring(3,5);


		terzoChar = strOra.charAt(2);

		// - CONTROLLI -
		// se ora o minuti non sono numeri
		if(isNaN(hour) || isNaN(minute)){
			alert("Ora non valida");
			obj.focus();
			obj.select();
			return false;
		}

		// se le ore sono comprese tra 0 e 23
		var hourInt = parseInt(hour);
		if(hourInt > 23 || hourInt < 0){
			alert("Ora non valida");
			obj.focus();
			obj.select();
			return false;
		}

		// se i minuti sono compresi tra 0 e 59
		var minuteInt = parseInt(minute);
		if(minuteInt > 59 || minuteInt < 0){
			alert("Minuti non validi");
			obj.focus();
			obj.select();
			return false;
		}

		// se il terzo carattere è un "." o ":"
		if(terzoChar != '.' && terzoChar != ':' ) {
			alert("Separatore non valido");
			obj.focus();
			obj.select();
			return false;
		}
		// ricostruisco l'ora esatta
		var exactOra = hour + ":" + minute;
		obj.value = exactOra;
	} // end if(len > 0)
	return true;
}
/*
ANTONELLO----------La seguente funzione si riferisce alla gestione sul tasso interesse
*/
function ContollaTasso(objName)
{
	if(objName.value > 100)
	{
		alert("Tasso maggiore della percentuale")
		return false;
	}
	return true;
}

// PEPPE
// Controlla il numero massimo di caratteri digitabili
// nei campi TEXTAREA i quali mancano della proprietà MAXLENGTH
function maxLengthNote(obj,max)
{
	if(obj.value.length>max-1)
	{
		obj.value = obj.value.substring(0,max-1);
		return false;
	}
	return true;

}

function maxLengthNoteUp(obj,max)
{
	if(obj.value.length>max)
	{
		obj.value = obj.value.substring(0,max);
		return false;
	}
	return true;

}

function TelFax(campo) {
  stringa = new String(campo.value);
  success = true;

  for(var i = 0; i<stringa.length;i++) {
     if(!((stringa.charAt(i)>=0) && (stringa.charAt(i)<=9) || (stringa.charAt(i)=='/'))) {
		success = false;
     }
   }
   if (success == false) {
       alert("Numero non corretto!");
	   campo.focus();
   }
}

function onlyNumbers()
{
  if (event.keyCode<48||event.keyCode>57)
  {
  		alert("Il campo può contenere solo valori numerici.");
		return false;
  }
  return true;
}



/*
Funzione per selezionare un valore in una combo tramite un filtro testo.
Si utilizza mettendo la seguente funzione sull' onkeyup del filtro testo
<input type="text" name="filtro" onkeyup="filtraCombo()">
function filtraCombo()
{
  var i = selectOptionOnFilter(this, document.[NOMEFORM].[NOMECOMBO]);
  document.[NOMECOMBO].selectedIndex = i;

}
*/
function selectOptionOnFilter(textFilter, combo)
{
 var inputTextUC = String(textFilter.value).toUpperCase();
 var inputLength = inputTextUC.length;

 if (inputLength <= 0)
  return -1;

 var options = combo.options;
 var countOptions = options.length;

 for (var i = 0; i < countOptions; i++)
 {
  if (options(i).value.substr(0, inputLength).toUpperCase() == inputTextUC)
  {
   break;
  }
 }

 if (i < countOptions)
  return i;
 else
  return -1;
}

/*******************************************************************************
Funzione che controlla la correttezza formale sull'immissione del codice CAB
*******************************************************************************/

function checkCodice(obj)
{
	var codice = obj.value;

	if (codice.length != 22)
	{
		alert("lunghezza errata!");
		return false;
	}

	var cDivisione = codice.substring(0,1);			//deve essere solo %, $, +.
	var cFornitore = codice.substring(1,5);			//deve essere alfanumerico.
	var cNMU = codice.substring(5,11);					//deve essere alfanumerico.
	var cStatoProdotto = codice.substring(11,12);	//deve essere alfanumerico.
	var anno = codice.substring(12,14);					//deve essere compreso fra 00 e 99.
	var mese = codice.substring(14,16);					//deve essere compreso fra 01 e 12.
	var cStabilimento = codice.substring(16,17);		//deve essere alfanumerico.
	var nSeriale = codice.substring(17,22);			//deve essere alfanumerico.

		var i, j, k;

	//controllo il codice divisione
//	alert(cDivisione.charAt(0));
	if (cDivisione.charAt(0)!='%' && cDivisione.charAt(0)!='$' && cDivisione.charAt(0)!='+')
	{
		alert("CAB ERRATO: Codice Divisione non corretto (carattere 1)");
		return false;
	}

	//controllo il codice fornitore
	//alert("cFornitore= " + cFornitore);
	//alert("lunghezza= " + cFornitore.length);
	for (i=0; i<cFornitore.length; i++)
	{
		//alert(cFornitore.charAt(i));
		if (!isAlfanum(cFornitore.charAt(i)))
		{
			alert("CAB ERRATO: Codice Fornitore non corretto (caratteri 2-5)");
			return false;
		}
	}

	//controllo il codice NMU
	for (j=0; j<cNMU.length; j++)
	{
		//alert(cNMU.charAt(j));
		if (!isAlfanum(cNMU.charAt(j)))
		{
			alert("CAB ERRATO: Codice NMU non corretto (caratteri 6-11)");
			return false;
		}
	}

	//controllo il codice Stato del prodotto
	//alert(cStatoProdotto.charAt(0));
	if (!isAlfanum(cStatoProdotto.charAt(0)))
	{
		alert("CAB ERRATO: Codice Stato del Prodotto non corretto (carattere 12)");
		return false;
	}

	//controllo l'anno
	var appAnno1 = anno.charAt(0);
	var appAnno2 = anno.charAt(1);
	//alert(anno.charAt(0)+anno.charAt(1));
	if ('0'<=anno.charAt(0) && anno.charAt(0)<='9')
	{
		if ('0'<=anno.charAt(1) && anno.charAt(1)<='9')
		{
			//alert("anno è OK!");
		}
		else
		{
			alert("CAB ERRATO: anno non corretto (caratteri 13-14) (seconda cifra) ");
			return false;
		}
	}
	else
	{
		alert("CAB ERRATO: anno non corretto (caratteri 13-14) (prima cifra) ");
		return false;
	}

	//controllo il mese
	var appMese1 = mese.charAt(0);
	var appMese2 = mese.charAt(1);
	//alert(mese.charAt(0)+mese.charAt(1));
	if ('0'==appMese1)
	{
		if ('0'<=appMese2 && appMese2<='9')
		{
			//alert("mese è OK!");
		}
		else
		{
			alert("CAB ERRATO: mese non corretto (caratteri 15-16) (seconda cifra) ");
			return false;
		}
	}
	else if ('1'==appMese1)
	{
		if ('0'<=appMese2 && appMese2<='2')
		{
			//alert("mese è OK!");
		}
		else
		{
			alert("CAB ERRATO: mese non corretto (caratteri 15-16) (seconda cifra) ");
			return false;
		}
	}
	else
	{
		alert("CAB ERRATO: mese non corretto (caratteri 15-16) (prima cifra) ");
		return false;
	}

	//controllo il codice stabilimento
	//alert(cStabilimento.charAt(0));
	if (!isAlfanum(cStabilimento.charAt(0)))
	{
		alert("CAB ERRATO: Codice Stabilimento non corretto (carattere 17)");
		return false;
	}

	//controllo il numero seriale
	for (k=0; k<nSeriale.length; k++)
	{
		//alert(nSeriale.charAt(k));
		if (!isAlfanum(nSeriale.charAt(k)))
		{
			alert("CAB ERRATO: Numero Seriale non corretto (caratteri 18-22)");
			return false;
		}
	}
	return true;
}


/*******************************************************************************
Funzione che controlla la correttezza di un carattere alfanumerico
*******************************************************************************/

function isAlfanum(arg)
{
	if ('a'<=arg && arg<='z')
	{
		//alert("carattere compreso fra 'a' e 'z'");
	}
	else if ('A'<=arg && arg<='Z')
	{
		//alert("carattere compreso fra 'A' e 'Z'");
	}
	else if ('0'<=arg && arg<='9')
	{
		//alert("carattere compreso fra '0' e '9'");
	}
	else
	{
//		alert("Stringa non alfanumerica");
		return false;
	}
	return true;
}

function checkAlfanum(obj)
{
	var stringa = obj.value;
	var arg = "";
	var lung = stringa.length;
	var i = 0;

	if (lung!=0)
	{
		for (i=0; i<lung; i++)
		{
			arg = stringa.charAt(i);
			if ('a'<=arg && arg<='z')
			{
				//alert("carattere compreso fra 'a' e 'z'");
			}
			else if ('A'<=arg && arg<='Z')
			{
				//alert("carattere compreso fra 'A' e 'Z'");
			}
			else if ('0'<=arg && arg<='9')
			{
				//alert("carattere compreso fra '0' e '9'");
			}
			else
			{
				alert("ATTENZIONE: valore immesso non corretto.");
				obj.focus();
				return false;
			}
		}
	}
	return true;
}

// Funzione che calcola il numero di giorni che intercorrono fra 2 date.
function contaGiorni(data1, data2)
{
	var giorno1 = data1.getDate();
	var giorno2 = data2.getDate();
	var mese1 	= data1.getMonth();
	var mese2 	= data2.getMonth();
	var anno1 	= data1.getYear();
	var anno2 	= data2.getYear();

	var feb = 28;
	if (isBisestile(anno1))
	{
		feb = 29;
	}
	var numGiorni = new Array(31,feb,31,30,31,30,31,31,30,31,30,31);

	if (mese2 == mese1)
	{
		return giorno2-giorno1;
	}
	var n = (numGiorni[mese1]-giorno1)+giorno2;
	if (mese2-mese1>1)
	{
		var delta = 0;
		for (i=mese1+1; i<mese2; i++)
		{
			delta = delta + numGiorni[i];
		}
		n = n + delta;
	}
	return n;
}
