// ---------------------------------------------------
// Descrizione:	Libreria Javascript di utilita'
// Versione:	1.0
// TabStop:		4
// ---------------------------------------------------

function getLayerById(id) {
	return document.all[id];
}

function getLayerStyleById(id) {
	return getLayerById(id).style;
}

function getCookie(nome) {
	var search = nome + "="
	var returnvalue = "";
	
	if (document.cookie.length > 0) {
		offset = document.cookie.indexOf(search)
		// if cookie exists
    	if (offset != -1) { 
    		offset += search.length
			// set index of beginning of value
			end = document.cookie.indexOf(";", offset);
			// set index of end of cookie value
			if (end == -1) end = document.cookie.length;
			returnvalue = unescape(document.cookie.substring(offset, end))
		}
	}
	return returnvalue;
}


function avverti(msg){
	alert("Attenzione!!!\n\n" + msg);
}


function avverti_eng(msg){
	alert("Pay attention, please!!!\n\n" + msg);
}


function replaceLF(str, strRep){
	str = str.replace(/\n/g, strRep);
	str = str.replace(/\r/g, "");
	return str;
}

function encodeURL(str){
	str = str.replace(/ /g, "%20");
	str = str.replace(/\"/g, "%22");
	str = str.replace(/\'/g, "%27");
	str = str.replace(/\+/g, "%2B");
	str = str.replace(/#/g, "%23");
	str = str.replace(/%/g, "%25");
	str = str.replace(/&/g, "%26");
	str = str.replace(/\?/g, "%3F");
	return str;
}


function getNomeFile(file){
	
	for(var n=file.length-1; n>-1; n--){
		if(file.charAt(n)=="/" || file.charAt(n)=="\\") {
			n++;
			break;
		}
	}
	if(n>-1 && n<file.length) return file.substring(n);
	return file;
}

function getEstensione(file){
	pos = file.lastIndexOf(".");
	if (pos == -1) return "";
	return file.substr(pos+1).toLowerCase();
}
		
function controllaEst(est, ammesse){
	if(ammesse.indexOf(est)<0) return false;
	return true;
}


function validaStringa(str, ammessi){
	for(n=0;n<str.length;n++) if (ammessi.indexOf(str.charAt(n))<0) return false;
	return true;
}

function validaStringaEx(str, nonAmmessi){
	for(n=0;n<str.length;n++) if (nonAmmessi.indexOf(str.charAt(n))>-1) return false;
	return true;
}


function redimPopup(win, larg, alt){
	var posX =(Math.round(screen.width/2))-(Math.round(larg/2));
	var posY =(Math.round(screen.height/2))-(Math.round(alt/2));
	win.resizeTo(larg, alt);
	win.moveTo(posX, posY);
}

function vaiPagina(url){
	document.location.href=url;
}

function apriPopup(url, finestra, larg, alt, opzioni){
	var posX =(Math.round(screen.width/2))-(Math.round(larg/2));
	var posY =(Math.round(screen.height/2))-(Math.round(alt/2));
	var win=window.open(url, finestra, opzioni+",width="+larg+",height="+alt+",top="+posY+",left="+posX);
	win.focus();
}




//---FUNZIONI DI VALIDAZIONE DELLE FORM----------------

// Descrizione: Controlla la correttezza di due date rappresentanti un periodo (inizio - fine)
//				provvedendo a mostrare relativi avvertimenti.
// Parametri: 	dataInizio = inizio periodo gg/mm/aaaa, dataFine = fine periodo gg/mm/aaaa,
//				dataOdierna = se != da "" abilita il controllo/errore per date future oltre la data odierna.
// Ritorno: 	true = date valide, false = errore nelle date/periodo
function ctrlPeriodo(dataInizio, dataFine, dataOdierna){
	
	if(! isDateS(dataInizio)){
		alert("Data di inizio non valida!!!\n\nInserire la data nel formato gg/mm/aaaa");
		return false;
	}
	if(! isDateS(dataFine)){
		alert("Data di fine non valida!!!\n\nInserire la data nel formato gg/mm/aaaa");
		return false;
	}
	
	if (dataOdierna != ""){
		if (! CfrDateS(dataInizio, dataOdierna)){
			alert("Data di inizio non valida!!!\n\nLa data di inizio non può essere futura.");
			return false;
		}
		if (! CfrDateS(dataFine, dataOdierna)){
			alert("Data di fine non valida!!!\n\nLa data di fine non può essere futura.");
			return false;
		}
	}
	
	if (! CfrDateS(dataInizio, dataFine)){
		alert("Periodo non valido!!!\n\nLa data di inizio è successiva alla data di fine.");
		return false;
	}
	
	return true;
}

// funzione di controllo di validità della data 
// compatibilità con Netscape 4.5, 4.7 , 6.0 ed Explorer 4, 5, 5.5
//IN 	: stringa di data nel formato giorno/mese/anno
//OUT	: true = data valida / false = data non valida
function isInDateRange(data, inizio, fine){
	gg		= data.split("/")[0]
	mm		= data.split("/")[1]
	aaaa	= data.split("/")[2]
	
	data = aaaa + "" + mm + "" + gg
	
	gg		= inizio.split("/")[0]
	mm		= inizio.split("/")[1]
	aaaa	= inizio.split("/")[2]
	
	inizio = aaaa + "" + mm + "" + gg
	
	gg		= fine.split("/")[0]
	mm		= fine.split("/")[1]
	aaaa	= fine.split("/")[2]
	
	fine = aaaa + "" + mm + "" + gg
	
	if (data >= inizio && data <= fine) return true 
	return false
}


// funzione di controllo di validità della data 
// compatibilità con Netscape 4.5, 4.7 , 6.0 ed Explorer 4, 5, 5.5
//IN 	: stringa di data nel formato giorno/mese/anno
//OUT	: true = data valida / false = data non valida
function isDateS(data)
{
	if (data.indexOf("/") == data.lastIndexOf("/") || data.indexOf("/") == -1 || data.lastIndexOf("/")==-1)
		return false
		
	gg		= data.split("/")[0]
	mm		= data.split("/")[1]
	aaaa	= data.split("/")[2]
	
	return (isDate(gg,mm,aaaa))
}

// funzione di controllo per data inserita in un campo triplice nel formato gg/mm/aaaa
// compatibilità con Netscape 4.5, 4.7 , 6.0 ed Explorer 4, 5, 5.5
//IN 	: variant giorno, variant mese, variant anno 4 cifre
//OUT	: true = data valida / false = data non valida
function isDate(gg,mm,aaaa)
{

		gg = Number(gg)
		mm = Number(mm)
 
	if(aaaa.length<4) return false;
	else
	{
		data = new Date(aaaa,mm-1,gg)
		gg1 = data.getDate()
		mm1 = data.getMonth()+1
		aaaa1 = data.getFullYear()
		
		datainput = gg+"/"+mm+"/"+aaaa
		dataresult = gg1+"/"+mm1+"/"+aaaa1
		if (dataresult!=datainput)
			return false
		else
			return true
	}	 	
}
// funzione di confronto fra date inserita in un campo singolo 
// compatibilità con Netscape 4.5, 4.7 , 6.0 ed Explorer 4, 5, 5.5

function CfrDateS(data, data1)
{
	
	gg1 = ""
	mm1 = ""
	aaaa1 = ""
	
		gg		= data.split("/")[0]
		mm		= data.split("/")[1]
		aaaa	= data.split("/")[2]
	
	if (data1!=""){
		gg1		= data1.split("/")[0]
		mm1		= data1.split("/")[1]
		aaaa1	= data1.split("/")[2]
	}
	
	return (CfrDate(gg,mm,aaaa,gg1,mm1,aaaa1))
}



// funzione di confronto fra date inserita in un campo triplice nel formato gg/mm/aaaa
// compatibilità con Netscape 4.5, 4.7 , 6.0 ed Explorer 4, 5, 5.5


function CfrDate(gg,mm,aaaa,gg1,mm1,aaaa1)
{
  
	data = new Date(aaaa,mm-1,gg)
	
	if (gg1=="" && mm1=="" && aaaa1=="")
		data1 = new Date()
	else
		data1 = new Date(aaaa1,mm1-1,gg1)
		
	if (data.getTime() > data1.getTime())
		return false
	else
		return true
}
//---FUNZIONE DI CONTROLLO VALIDITA'EMAIL----------------

function isEmail(email){
	invalidChars = " /:,;\""
	for(i=0;i<invalidChars.length;i++)
	{
		badChar = invalidChars.charAt(i)
		if(email.indexOf(badChar,0)>-1)
			return false
	}
	atPos = email.indexOf("@",1)
	if (atPos == -1)
		return false
	if (email.indexOf("@",atPos +1)>-1)
		return false
	periodPos = email.indexOf(".",atPos)
	if (periodPos ==-1)
		return false
	if (periodPos+3 > email.length)
		return false
	return true
}


//---FUNZIONI DI UTILITA' PER STRINGHE----------------

// Descrizione: Rimpiazza un carattere in una stringa con un altro
// I: sz = Stringa
// I: szOld = Vecchio Carattere
// I: szNew = Nuovo Carattere
// R: Stringa con caratteri Rimpiazzati
function utlReplace(sz, szOld, szNew)
{
	var szRet = "";
	var szChar;

	for (var i=0; i<sz.length; i++)
	{	
		if ( (szChar = sz.charAt(i)) == szOld)
		{
			szRet += szNew;
		}
		else
		{
			szRet += szChar;
		}
	}

	return szRet;
}

// Descrizione: Rimpiazza un stringa vuota con la stringa desiderata
// I: sz = Stringa
// I: szNew = Nuova Stringa
// R: Stringa
function utlReplaceEmpty(szOld, szNew)
{
    var szRet = "";
    var ch    = "";
    var bChar = true;

    if(!szOld == "")
    {
	    for (i=0; i<szOld.length; i++)
	    {
		ch = szOld.charAt(i);
		if (ch != " ")
		  bChar = false;
	    }
    }

    szRet = (bChar)?szNew:szOld;

    return szRet;
}

// Descrizione: Eliminazione spazi a Sinistra e a Destra in una stringa.
// I: sz = Stringa da cui eliminare gli spazi
// R: stringa senza spazi.
function utlTrim(sz)
{
    var ch; var i;
	var nStart = 0; var nEnd = sz.length;

    for (i=0; i<sz.length; i++)
    {
        ch = sz.charAt(i);
        if (ch != " ")
        {
            nStart = i;
            i=sz.length;
        }
    }
    if (i==sz.length)
        return "";
    for (i=(sz.length -1); i>=0; i--)
    {
        ch = sz.charAt(i);
        if (ch != " ")
        {
            nEnd = i+1;
            i=-1;
        }
    }
    return sz.substring(nStart, nEnd);
}

// Descrizione: Funzione per eliminare CR LF da una Stringa
// I: sz		= Stringa da analizzare
// R: Stringa senza CR LF
function utlSkipCRLF(sz)
{
	var szRet = "";
	var ch;

	for (var i=0; i<sz.length; i++)
	{
		ch = sz.charAt(i);
		if (ch == '\r')
			szRet += " ";
		else if (ch == '\n') {}
		else
			szRet += ch;
	}
	return szRet;
}

// Descrizione: Controlla che la stringa contenga solo Cifre.
// I: sz = Stringa da controllare
// R: true se la stringa contiene caratteri non ammessi, false altrimenti.
function utlCheckCifre(sz)
{
	var codes="0123456789";
	for(i=0; i<sz.length; i++) if (codes.indexOf(sz.charAt(i))==-1) return true;
	return false;
}


// Descrizione: Controlla l'esattezza di una data.
// I: szData = Stringa contenente la data da controllare
// R: true se la data e' corretta, false se e' errata.
function utlCheckData(szData)
{
	var anDays = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
	if (szData.length < 10)
	{
		alert("Inserire la data nel formato \"gg/mm/aaaa\".");
		return false;
	}

	if(szData.substr (2,1)!= "/" || szData.substr (5,1)!= "/"){alert("Inserire la data nel formato gg/mm/aaaa");return false};

	szDay = szData.substring (0,2);
	szMonth = szData.substring (3,5);
	szYear = szData.substring (6);

	if (utlCheckCifre(szDay) || utlCheckCifre(szMonth) || utlCheckCifre(szYear))
	{
		alert("Sono stati immessi caratteri non validi per la data.");
		return false;
	}

	if (leapYear(szYear) == 1)
		anDays[1] = 29;
	if (szYear < 1900)
	{
		alert("Anno non valido.");
		return false;
	}
	if (szMonth < 1 || szMonth > 12)
	{
		alert("Mese non valido.");
		return false;
	}
	if ( szDay > anDays[szMonth-1])
	{
		alert("Giorno non valido.");
		return false;
	}
	return true;
}

// Descrizione: Controlla che la stringa contenga  solo lettere e numeri.
// I: s = Stringa da controllare
// R: 1 se la stringa contiene caratteri non ammessi, 0 altrimenti.
function utlCarletnum(s)
{
	var codes=" `’abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZàèéìòù,.:-0123456789@\\/()!?;<>'=%\"";
	var l=s.length;
	var flag=0;
	for(i=0; i<l; i++) if (codes.indexOf(s.charAt(i))==-1) flag=1;
	return flag;
}

// Descrizione: Controlla che la stringa contenga caratteri validi per un numero di telefono
// I: sz = Stringa da controllare
// R: true se la stringa contiene caratteri non ammessi, false altrimenti.
function utlCheckTel(sz)
{
	var codes="/-0123456789";
	for(i=0; i<sz.length; i++) if (codes.indexOf(sz.charAt(i))==-1) return true;
	return false;
}

// Descrizione: Controlla la correttezza di un indirizzo e-mail
// I: sz = Stringa da controllare
// R: true se la stringa contiene caratteri non ammessi, false altrimenti.
function utlCheckEmail(sz)
{
	var codes="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.0123456789@";
	var l=sz.length;
	var nCtr = 0;

	for(i=0; i<l; i++)
	{
		if (codes.indexOf(sz.charAt(i))==-1)
			return true;
	}

	for(i=0; i<l; i++)
	{
		if (sz.charAt(i) == '@')
			nCtr++;
	}

	if (nCtr != 1)
		return true;

	return false;
}

// Descrizione: Controlla che la stringa contenga solo cifre, '- ,.'.
// I: s = Stringa da controllare
// R: 1 se la stringa contiene caratteri non ammessi, 0 altrimenti.
function utlCarnum(s)
{
	var codes="- 0123456789,.";
	var l=s.length;
	var flag=0;
	for(i=0; i<l; i++) if (codes.indexOf(s.charAt(i))==-1) flag=1;
	return flag;
}

// Descrizione: Controlla che la stringa contenga solo cifre, '- ,.'.
// I: s = Stringa da controllare
// R: 1 se la stringa contiene caratteri non ammessi, 0 altrimenti.
function utlCarOnlyNum(s)
{
	var codes="0123456789";
	var l=s.length;
	var flag=0;
	for(i=0; i<l; i++) if (codes.indexOf(s.charAt(i))==-1) flag=1;
	return flag;
}


// Descrizione: Controlla che la stringa contenga solo lettere.
// I: s = Stringa da controllare
// R: 1 se la stringa contiene caratteri non ammessi, 0 altrimenti.
function utlCarlet(s)
{
	var codes=" 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZàèéìòù";
	var l=s.length;
	var flag=0;
        for(i=0; i<l; i++) if (codes.indexOf(s.charAt(i))==-1) flag=1;
	return flag;
}


// Descrizione: Controlla la correttezza di due date rappresentanti un periodo.
// I: dataIni	= Data Inizio periodo.
// I: dataFine	= Data Fine periodo.
// I: sysdate	= se va effettuato il controllo "La data di inizio è precedente alla data odierna.", 0 altrimenti (parametro opzionale).
// I: flag		= 1 se va effettuato il controllo sulla prima data,
//				  2 se va effettuato anche sulla seconda, 0 altrimenti (parametro opzionale).
// R: 1 se la date sono corrette, 0 altrimenti.
function utlData(dataIni,dataFine,sysDate,flag)
{
	var yearIni,monthIni,dayIni,dayFine,monthFine,yearFine,yearSys,monthSys,daySys,dataOd;
	var comDataIni;
	var comDataFine;

	if (isNaN(flag))
		flag=0;

	if(isNaN(parseInt(sysDate))){sysDate=dataIni;}

	if(flag == 1)
	{
		if(dataIni.length < 10){alert("Inserire la data nel campo DAL nel formato gg/mm/aaaa");return false};
		if(dataFine.length < 10){alert("Inserire la data nel campo AL nel formato gg/mm/aaaa");return false};		
	}
	if(flag > 1)
	{
		if(dataFine.length < 10){alert("Inserire la data nel campo AL nel formato gg/mm/aaaa");return false};
	}

	if (dataIni != "")
	{
		if(dataIni.length < 10){alert("Inserire la data nel campo DAL nel formato gg/mm/aaaa");return false};
		if(dataIni.substr (2,1)!= "/" || dataIni.substr (5,1)!= "/"){alert("Inserire la data nel campo DAL nel formato gg/mm/aaaa");return false};

		dataIni  = utlReturnDMY(dataIni);

		dayIni   = dataIni[0];
		monthIni = dataIni[1];
		yearIni  = dataIni[2];

		val = getDaysInMonth(monthIni,yearIni);

		if (isNaN(yearIni.valueOf()))
		{
	            alert("Anno non valido");
        	    return 0;
		}

		if (monthIni.valueOf() < 1 ||monthIni.valueOf() > 12|| isNaN(monthIni.valueOf()))
		{
        	    alert("Il formato del mese non e' valido!");
	            return 0;
		}

		if (dayIni.valueOf() > val || isNaN(dayIni.valueOf()) || (dayIni.valueOf()<1))
		{
        	    alert("Il formato del giorno non e' valido!");
	            return 0;
		}

		comDataIni  = parseInt(yearIni+monthIni+dayIni);

	}

	if (dataFine != "")
	{
		if(dataFine.length < 10){alert("Inserire la data nel campo AL nel formato gg/mm/aaaa");return false};
		if(dataFine.substr (2,1)!= "/" || dataFine.substr (5,1)!= "/"){alert("Inserire la data nel campo AL nel formato gg/mm/aaaa");return false};

		dataFine  = utlReturnDMY(dataFine);

		dayFine = dataFine[0];
		monthFine =dataFine[1];
		yearFine = dataFine[2];

		val = getDaysInMonth(monthFine,yearFine);

		if (isNaN(yearFine.valueOf()))
		{
	            alert("Anno non valido");
        	    return 0;
		}

		if (monthFine.valueOf() < 1 || monthFine.valueOf() > 12|| isNaN(monthFine.valueOf()))
		{
        	    alert("Il formato del mese non e' valido!");
	            return 0;
		}

		if (dayFine.valueOf() > val || isNaN(dayFine.valueOf()) || (dayFine.valueOf()<1))
		{
        	    alert("Il formato del giorno non e' valido!");
	            return 0;
		}

		comDataFine = parseInt(yearFine+monthFine+dayFine);

		if(comDataIni > comDataFine){alert("La data iniziale non può essere successiva alla data finale.");return 0;}
	}

	if(flag)
	{
		dataOd=utlReturnDMY(sysDate);

		comDataSys  = dataOd[2]+dataOd[1]+dataOd[0];
		comDataSys  = parseInt(comDataSys);

		if(comDataIni < comDataSys)
		{
			alert("La data di inizio è precedente alla data odierna.");
			return 0;
		}
	}

    return 1;
}

// Descrizione: Controllo anno bisestile.
// I: Year = anno da controllare.
// R: 1 l'anno e' bisestile, 0 l'anno non e' bisestile.
function leapYear (Year)
{
    if (((Year % 4)==0) && ((Year % 100)!=0) || ((Year % 400)==0))
        return (1);
    else
        return (0);
}

// Descrizione: Ritorna il numero dei giorni in un mese (con controllo sulla bisestilita' dell'anno)
// I: month	= Mese.
// I: year	= Anno.
// R: Numeri di giorni del mese.
function getDaysInMonth(month,year)
{
	var days;
	if (month==1 || month==3 || month==5 || month==7 || month==8 || month==10 || month==12)
		days=31;
	else if (month==4 || month==6 || month==9 || month==11)
		days=30;
	else if (month==2)
	{
		if (leapYear (year)==1)
			days=29;
		else
			days=28;
	}
    return (days);
}


// Descrizione: Formattazione della data di sistema
// I: sysDate	= Data di sistema.
// R: Data di sistema formattata (gg/mm/aaaa).
function utlReturnData(sysDate){

	var newDate,Data;

	newDate=utlReturnDMY(sysDate);

	Data = newDate[0] + '/' + newDate[1] + '/' + newDate[2];
	return Data;
}

// Descrizione: Ritorno del giorno, mese, anno in un array
// I: sysDate	= Data di sistema.
// R: array di stringhe [0]=giorno, [1]=mese, [2]=anno.
function utlReturnDMY(sDate){

	var sDay,sMonth,sYear,sArray;

	sDay   = sDate.substr (0,2);
	sMonth = sDate.substr (3,2);
	sYear  = sDate.substr (6,4);

	sArray = new Array(3);

	sArray[0]=sDay;
	sArray[1]=sMonth;
	sArray[2]=sYear;

	return sArray;
}

// Descrizione: Funzione per Comporre URL
// I: szName	= Nome parametro
// I: szVal		= Valore parametro
// I: f			= Ultimo pair se true
// R: URL
function utlMakeURL(szName, szVal, f)
{
	szURL = szName + "=";
	szURL += escape(szVal);
	if (!f) szURL += "&";
	return szURL;
}

function utlAllegato_window(szUploadWWWRoot, pdfFile)
{
	var szAllegato = utlTrim(pdfFile);

	if (szAllegato == ".")
	{
		alert("Allegato non disponibile.");
	}
	else
	{
		var FX=640
		var FY=480
		var X =(Math.round(screen.width/2))-(Math.round(FX/2))
		var Y =(Math.round(screen.height/2))-(Math.round(FY/2))
		win=window.open(szUploadWWWRoot + szAllegato ,"dettaglio","width="+FX+",height="+FY+",status=no,toolbar=yes,menubar=yes,scrollbars=no,resizable=yes,top="+Y+",left="+X);
		win.focus()
	}
}

// Descrizione: Controlla l'esattezza delle ore.
// I: szHours = Stringa contenente l' ora da controllare
// R: true se l'ora e' corretta, false se e' errata.
function utlCheckOra(szHours)
{
	if (szHours.length < 5)
	{
		alert("Inserire l'ora nel formato \"HH24:MI\".");
		return false;
	}

	if(szHours.substr (2,1)!= ":"){alert("Inserire l'ora nel formato \"HH24:MI\".");return false};

	szHour = szHours.substring (0,2);
	szMinutes = szHours.substring (3,5);

	if (utlCheckCifre(szHour) || utlCheckCifre(szMinutes))
	{
		alert("Sono stati immessi caratteri non validi per l'ora.");
		return false;
	}

	if (parseInt(szHour) > 23 || parseInt(szHour) < 0)
	{
		alert("Ora non valida (00-23).");
		return false;
	}
	if (parseInt(szMinutes) > 59 || parseInt(szMinutes) < 0)
	{
		alert("Minuti non validi (00-59).");
		return false;
	}

	return true;
}

// Descrizione: Controlla che un orario non sia superiore ad un altro
// I: szOrario1 = Primo orario
// I: szOrario2 = Secondo orario
// R: true se il primo orario e' inferiore al secondo, false altrimenti
function utlCheckRangeOra(szOrario1, szOrario2)
{
	var nHH1 = szOrario1.substring (0, 2) + szOrario1.substring(3, 5);
	var nHH2 = szOrario2.substring (0, 2) + szOrario2.substring(3, 5);
	var fRet = true;

	if (parseInt(szOrario2.substring (0, 2)) == 0)
		nHH2 = 9999;

	if (nHH1 > nHH2)
		fRet = false;

	return fRet;
}