/**

Funzioni di utilita' compatibili con Internet Explorer e Netscape Communicator, utilizzate
per la validazione dei campi di input di una form.

Autore: Raffaele Apisa

**/

//////////////////////////////////////////////////////////////////////////////////////////// 

/*

DICHIARAZIONE DEGLI OGGETTI UTILIZZATI PER RAPPRESENTARE I CAMPI DI UNA FORM

Ogni valore digitabile viene modellato con il corrispondente oggetto. Per esempio, myInteger
e' l'oggetto che rappresenta un campo che deve contenere numeri interi.
Ogni oggetto ha delle proprieta' che lo caratterizzano ed esse vengono inizializzate dal
costruttore dell'oggetto.
Per istanziare un oggetto va usato l'operatore new.
Ex:
 	var x = new myInteger("importo","3","7","100","5555555",true);

La precedente istruzione crea un oggetto di tipo myInteger assegnando alla proprieta'
name il valore "importo", alla proprieta' min_cifre il valore 3, alla proprieta' max_cifre il valore 7, alla proprieta' min_value il valore 100, alla proprieta' max_value il valore 5555555,
alla proprieta' required il valore true.
I parametri numerici possono essere invocati anche senza i doppi apici, quindi la seguente istruzione:

	var x = new myInteger("importo",3,7,100,5555555,true);

risulta ugualmente corretta.



N.B.

E' stato fatto un controllo sulla correttezza della lista dei parametri del costruttore.
Questo vuol dire che se l'oggetto viene istanziato passando al costruttore un numero non corretto
di argomenti, viene dato un opportuno messaggio.
Qualora comparisse un tale messaggio, bisogna controllare la chiamata al costruttore e correggere
l'errore, altrimenti la funzione validaForm (quella adibita al controllo della correttezza dei dati) elude i controlli sull'oggetto su cui e' occorso l'errore.

*/
  
///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta un numero intero
*/

function myInteger(name,min_cifre,max_cifre,min_value,max_value,required){

	this.name = name;           //nome campo HTML
	this.min_cifre = min_cifre; //minimo numero cifre
	this.max_cifre = max_cifre; //massimo numero cifre
	this.min_value = min_value; //valore minimo 
	this.max_value = max_value; //valore massimo 	
	this.required = required;   //true obbligatorio, false non obbligatorio
	this.type = "integer";       //tipo di oggetto  

	if(min_cifre == null || min_cifre=="") this.min_cifre = 0; //minimo numero di cifre di default
	if(max_cifre == null || max_cifre=="") this.max_cifre = 20; //massimo numero di cifre di default
	if(min_value == null || min_value=="") this.min_value = -10000000000; //minimo valore di default
	if(max_value == null || max_value=="") this.max_value = 10000000000; //massimo valore di default
	
//controllo che il costruttore sia stato invocato nel modo corretto
	
	if(this.name==null || this.required==null)	

		alert("ATTENZIONE!\nIl costruttore dell'oggetto myInteger non e' stato invocato correttamente.Correggere l'errore.");  									
}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta un numero float
*/

function myFloat(name,cifre_parte_intera,cifre_parte_decimale,min_value,max_value,required){

	this.name = name;				  //nome campo HTML
	this.cifre_parte_intera = cifre_parte_intera;     //max numero di cifre parte intera
	this.cifre_parte_decimale = cifre_parte_decimale; //max numero di cifre parte decimale
	this.min_value = min_value;			  //valore minimo 	
	this.max_value = max_value;			  //valore massimo 
	this.required = required;			  //true obbligatorio, false non obbl.	
	this.type = "float";     //tipo di oggetto  


	if(cifre_parte_intera == null || cifre_parte_intera=="") this.cifre_parte_intera = 12; //max numero di cifre intere di default
	if(cifre_parte_decimale == null || cifre_parte_decimale=="") this.cifre_parte_decimale = 6; //max num di cifre decim. di default
	if(min_value == null || min_value=="") this.min_value = -10000000000; //minimo valore di default
	if(max_value == null || max_value=="") this.max_value = 10000000000; //massimo valore di default

//controllo che il costruttore sia stato invocato nel modo corretto
	if(this.name==null || this.required==null)	
		alert("ATTENZIONE!\nIl costruttore dell'oggetto myFloat non e' stato invocato correttamente.Correggere l'errore."); 									 

}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta un indirizzo di posta elettronica
*/

function myMail(name,required){

	this.name = name;         //nome campo HTML
	this.required = required; //true obbligatorio, false non obbl.
	this.type = "mail";       //tipo di oggetto  
	

//controllo che il costruttore sia stato invocato nel modo corretto

	if(this.name==null || this.required==null)

	alert("ATTENZIONE!\nIl costruttore dell'oggetto myMail non e' stato invocato correttamente.Correggere l'errore."); 						 
}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta una data
*/

function myDate(name,formato,min_value,max_value,required){

	this.name = name;		//nome campo HTML
	this.formato = formato;		//formato che la data deve assumere
	this.min_value = min_value;	//valore minimo della data
	this.max_value = max_value;	//valore massimo della data
	this.required = required;	//true obbligatorio, false non obbl.
	this.type = "date";       //tipo di oggetto  


	if(formato == null || formato=="") this.formato = "dd/mm/yyyy"; //formato di default
	if(min_value==null || min_value=="") this.min_value = "01/01/1900"; //minimo valore di default
	if(max_value==null || max_value=="") this.max_value = "31/12/3000"; //massimo valore di default		

//controllo che il costruttore sia stato invocato nel modo corretto
		
	if(this.name==null || this.required==null)
		 	
		alert("ATTENZIONE!\nIl costruttore dell'oggetto myDate non e' stato invocato correttamente.Correggere l'errore."); 						 
}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta una time
*/

function myTime(name,formato,min_value,max_value,required){

	this.name = name;		//nome campo HTML
	this.formato = formato;		//formato che l'orario deve assumere
	this.min_value = min_value;	//valore minimo dell'ora
	this.max_value = max_value;	//valore massimo dell'ora
	this.required = required;	//true obbligatorio, false non obbl.
	this.type = "time";       //tipo di oggetto  


	if(formato == null || formato=="") this.formato = "hh:mm"; //formato di default
	if(min_value==null || min_value=="") this.min_value = "00:00"; //minimo valore di default
	if(max_value==null || max_value=="") this.max_value = "23:59"; //massimo valore di default		

//controllo che il costruttore sia stato invocato nel modo corretto
		
	if(this.name==null || this.required==null)
		 	
		alert("ATTENZIONE!\nIl costruttore dell'oggetto myTime non e' stato invocato correttamente.Correggere l'errore."); 						 
}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta un campo alfanumerico generico
	La sigla GFAN sta per "Generic Field Alphanumeric" 
*/

function myGFAN(name,max_length,required){

	this.name = name;		//nome campo HTML
	this.max_length = max_length;	//lunghezza massima della stringa
	this.required = required;	//true obbligatorio, false non obbl.
	this.type = "gfan";       //tipo di oggetto  


	if(max_length == null || max_length=="") this.max_length = 1000; //max numero di caratteri digitabili di default

//controllo che il costruttore sia stato invocato nel modo corretto
	if(this.name == null || this.required == null) alert("ATTENZIONE!\nIl costruttore dell'oggetto myGFAN non e' stato invocato correttamente.Correggere l'errore."); 			 

}

///////////////////////////////////////////////////////////////////////////////////////////
/*
	definisco un oggetto che rappresenta un campo alfabetico generico
	La sigla GFA sta per "Generic Field Alphabetic" 
*/

function myGFA(name,max_length,required){

	

	this.name = name;		//nome campo HTML
	this.max_length = max_length;	//lunghezza massima della stringa
	this.required = required;	//true obbligatorio, false non obbl.
	this.type = "gfa";       //tipo di oggetto  
	
	
	if(max_length == null || max_length=="") this.max_length = 1000; //numero grande di caratteri digitabili

//controllo che il costruttore sia stato invocato nel modo corretto
	if(this.name == null || this.required == null) alert("ATTENZIONE!\nIl costruttore dell'oggetto myGFA non e' stato invocato correttamente.Correggere l'errore."); 			 
	
}

///////////////////////////////////////////////////////////////////////////////////////////

/*
	definisco un oggetto che rappresenta un numero float in formato euro italiano
*/

function myEuroItalia(name,cifre_parte_intera,cifre_parte_decimale,min_valore,max_valore,required){

	
	this.name = name;				  //nome campo HTML
	this.cifre_parte_intera = cifre_parte_intera;     //max numero di cifre parte intera
	this.cifre_parte_decimale = cifre_parte_decimale; //max numero di cifre parte decimale
	this.min_value = min_valore;			  //valore minimo 	
	this.max_value = max_valore;			  //valore massimo 
	this.required = required;			  //true obbligatorio, false non obbl.	
	this.type = "euro_italia";     //tipo di oggetto  

			
	if(cifre_parte_intera == null || cifre_parte_intera=="") this.cifre_parte_intera = 12; //max numero di cifre intere di default
	if(cifre_parte_decimale == null || cifre_parte_decimale=="") this.cifre_parte_decimale = 6; //max num di cifre decim. di default
	if(min_valore == null || min_valore=="") this.min_value = -10000000000; //minimo valore di default
	if(max_valore == null || max_valore=="") this.max_value = 10000000000; //massimo valore di default

//controllo che il costruttore sia stato invocato nel modo corretto
	if(this.name==null || this.required==null)	
		alert("ATTENZIONE!\nIl costruttore dell'oggetto myEuroItalia non e' stato invocato correttamente.Correggere l'errore."); 									 

	//alert("this.min_value vale "+ this.min_value)
	//alert("this.max_value vale "+ this.max_value)
}

//////////////////////////////////////////////////////////////////////////////////////////

/*

 FINE DICHIARAZIONE DEGLI OGGETTI UTILIZZATI PER RAPPRESENTARE I CAMPI DI UNA FORM

*/
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

  Questa funzione controlla se un oggetto di input (oggetto di form) sia valorizzato.
  In caso negativo la funzione lancia un alert opportuno, mette il focus sul campo stesso
  e restituisce valore false.
  Se il campo e' valorizzato ritorna valore true.
  Quindi il parametro obj passato alla funzione e' un campo(oggetto) di una form, come text, password, select, etc.	
*/

function oggettoIsValorizzato(obj) {

 

	tipo=obj.type; //determino il tipo di oggetto da esaminare

	if((tipo=="text" || tipo=="password") && obj.value==""){ //se textfield o password
		alert(obj.name + " e' obbligatorio");
		obj.focus();
		return false;
	}
	else if(tipo=="textarea" && isStringaVuota(obj.value)){
		alert(obj.name + " e' obbligatorio");
		obj.focus();	
		return false;
	}
	else if(tipo=="select-one"){ //combo a selezione singola
		alert("combo");
		//controllo se e' stata selezionata una voce
		var selNum = obj.selectedIndex; //indice dell'opzione selezionata
		var selText = obj.options[selNum].text; //valore dell'opzione selezionata
		if(selText=="" || selText==null){ alert(obj.name + " e' obbligatorio");
		//obj.focus();
		return false;
		}
	}

	else if(tipo=="select-multiple"){ //combo a selezione multipla
		//controllo se e' stata selezionata una voce
		var selNum = obj.selectedIndex; //indice dell'opzione selezionata
		
		if(selNum!=-1){ //e' stata selezionata un opzione
			var selText = obj.options[selNum].text;				
			if(selText==""){ //se l'opzione selezionata non e' valorizzata
				alert(obj.name+ " e' obbligatorio");
				obj.focus();	
				return false;
			}
		}
		else if(selNum==-1) { //non e' stata selezionata alcuna opzione
			alert(obj.name+ " e' obbligatorio");
			obj.focus();
			return false;
		}
		
		
	}
	else return true;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	Controlla che la stringa passata come parametro non contenga tutti blank	

*/

function isStringaVuota(str){

	
	for(x=0; x < str.length; x++){

		if(str.charAt(x)!="") return false;
	}

	return true;

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	Questa funzione analizza se una data soddisfa due requisiti:
	1) Deve essere nel formato specificato dal parametro <formato>
	2) Se e' nel formato giusto, deve essere una data valida; Ex: 32/04/2000 non e' una data valida

	I parametri di input sono obj che rappresenta il campo(oggetto) di una form e formato che rappresenta la stringa che 		serve a formattare la data.
*/

function validaFormatoData(obj,formato,minval,maxval){


	if(obj.value=="") return true;
	if(!isDate(obj,formato)){ // controllo sulla correttezza del formato
		alert("La data non e' in formato corretto.Deve avere il formato "+formato);
		return false;
	}
	else{
		 if(!isValidDate(obj,formato)){ //controllo sulla validita' della data
			alert("La data non e' valida");
			return false;	
		 }		
	}	
	
	data_esaminata = obj.value; //data letta dalla casella di testo
	//ok = (data_esaminata >= data1 && data_esaminata <= data2)
	ok = (compareDate(data_esaminata,minval)>=0 && compareDate(data_esaminata,maxval)<=0)
		
	if(!ok){
		alert("La data non e' nell'intervallo corretto.Deve essere compresa tra " + minval + " e " + maxval);
		return false;
	}
	return true;

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
    controlla la correttezza del formato. Il pattern matching viene costruito su tre tipi di formato possibili:
    "dd/mm/yyyy", "dd-mm-yyyy","dd.mm.yyyy"
    se viene passato un formato non valido viene lanciato un opportuno messaggio di errore.
    Notare che viene sfruttato il meccanismo delle espressioni regolari.

*/

function isDate(field,formato) {
	

	formato = formato.toLowerCase();	

	if(formato=="dd/mm/yyyy" || formato=="gg/mm/aaaa"){
		datePattern = /^[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}$/;
	}
	else if(formato=="dd-mm-yyyy" || formato=="gg-mm-aaaa"){
		datePattern = /^[0-9]{1,2}\-[0-9]{1,2}\-[0-9]{4}$/;
	}
	else if(formato=="dd.mm.yyyy" || formato=="gg.mm.aaaa"){
		datePattern = /^[0-9]{1,2}\.[0-9]{1,2}\.[0-9]{4}$/;
	}
	else{
		alert("Attenzione!\nErrore nella funzione JavaScript isDate: formato "+formato +" non riconosciuto.");
		return false;
	}	

	return (field.value == "" || datePattern.test(field.value));	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

Controlla che la data sia corretta, includendo anche il controllo sugli anni bisestili

*/

function isValidDate(dateField,formato)
{
	var arr = new Array();

	formato = formato.toLowerCase();	

	if(formato=="dd/mm/yyyy" || formato=="gg/mm/aaaa"){
		arr = dateField.value.toString().split('/');	
	}
	else if(formato=="dd-mm-yyyy" || formato=="gg-mm-aaaa"){
		arr = dateField.value.toString().split('-');	
	}
	else if(formato=="dd.mm.yyyy" || formato=="gg.mm.aaaa"){
		arr = dateField.value.toString().split('.');	
	}
	else{
		alert("Attenzione!\nErrore nella funzione JavaScript isValidDate: formato "+formato +" non riconosciuto.");
		return false;
	}
	
	
	
	var day = arr[0];
	var month = arr[1];
	var year = parseInt(arr[2],10);
	

	if (day > 31 || month > 12 || (day==29 && month==2 && !isAnnoBisestile(year)) ) return false;

	// Using form values, create a new date object
	var myDate = new Date(arr[2],arr[1]-1,day);
	
	return (myDate.getDate() == day);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 /*
	Questa funzione valuta se un anno e' bisestile o meno, con il seguente algoritmo:
	un anno e' bisestile se e' divisibile per 4 ma non per 100. Tuttavia e' bisestile un anno 
	divisibile per 400, come l'anno 2000.	
 */

function isAnnoBisestile(anno){


	if(anno % 400 ==0) return true;
	else{
		return ((anno%4==0) && (anno%100!=0));
	} 


}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	La funzione controlla che <elem> sia un numero reale e poi verifica che abbia il formato corretto
*/

function validaFormatoFloat(elem,cifre_intere,cifre_decimali,minval,maxval){

        if(elem.value=="") return true;

	var numero = new Array();
	
	numero = elem.value.toString().split('.');
	
	if(numero[1]==null || numero[1]=="") { //non ci sono cifre decimali
		var pattern = new RegExp("^[\-]{0,1}[0-9]{0,"+parseInt(cifre_intere,10)+"}$");
	} 		
	else{ //sono presenti cifre decimali
		var pattern = new RegExp("^[\-]{0,1}[0-9]{0,"+parseInt(cifre_intere,10)+"}[\.]{0,1}[0-9]{0,"+parseInt(cifre_decimali,10)+"}$");		
	}

	// alert("pattern = "+pattern);	

	ok1 = isNumeric(elem);
	if(!ok1){
		alert(elem.name+" deve essere un numero.");
		return false;
	}

	ok2 = elem.value.match(pattern)!=null ? true : false;

	if(!ok2){
		alert(elem.name+" non ha il formato numerico corretto");
		return false;
	}

	ok3 = (parseFloat(elem.value) >= parseFloat(minval) && parseFloat(elem.value) <= parseFloat(maxval));
	if(minval==null || maxval==null) ok3 = true; //il confronto col min e max viene bypassato.
	
	if(!ok3){
		alert(elem.name+" non e' nell'intervallo consentito. Il valore minimo consentito e' "+ parseFloat(minval) + " Il valore massimo consentito e' "+parseFloat(maxval));
		return false;
		
	}

	ok = (ok1 && ok2 && ok3); 
		
	return ok;

}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	La funzione controlla che <elem> sia un numero reale e poi verifica che abbia il formato euro italiano,
	che vede la parte intera separata dalla decimale da una virgola
*/

function validaFormatoEuroItalia(elem,cifre_intere,cifre_decimali,minval,maxval){

        if(elem.value=="") return true;

	var numero = new Array();
	
	numero = elem.value.toString().split(',');
	
	ok1 = isNumericEuroItalia(elem,cifre_intere,cifre_decimali);
	
	if(!ok1){
		return false;
	}
	
			
	if(minval==null && maxval==null) ok2 = true; //il confronto col min e max viene bypassato.
	
	ok2 = (parseFloat(converteEuroFloat(elem.value)) >= parseFloat(converteEuroFloat(minval)) && parseFloat(converteEuroFloat(elem.value)) <= parseFloat(converteEuroFloat(maxval)));
			
	if(!ok2){
		alert(elem.name+" non e' nell'intervallo consentito. Il valore minimo consentito e' "+ parseFloat(converteEuroFloat(minval)) + " Il valore massimo consentito e' "+parseFloat(converteEuroFloat(maxval)));
		return false;
		
	}
  
  
	ok = (ok1 && ok2); 
			
	return ok;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	La funzione controlla che <elem> sia un numero intero e poi verifica che abbia il formato corretto
*/


function validaFormatoInteger(elem,cifre_min,cifre_max,value_min,value_max){

       	if(elem.value=="") return true;
	var pattern = new RegExp("^[\-]{0,1}[0-9]{0,"+parseInt(cifre_max,10)+"}$");

	// alert("pattern = "+pattern);	

	ok1 = isNumeric(elem);
	if(!ok1){
		alert(elem.name+" deve essere un numero.");
		return false;
	}
	ok2 = elem.value.match(pattern)!=null ? true : false;

	if(!ok2){
		
		alert(elem.name+" non ha il formato numerico corretto");
		return false;
	}

	ok3 = (elem.value.length <= parseInt(cifre_max,10) && elem.value.length >= parseInt(cifre_min,10))

	if(!ok3){
		
		alert(elem.name+" non ha il formato numerico corretto");
		return false;
	}

	ok4 = (parseInt(elem.value,10) >= parseInt(value_min,10) && parseInt(elem.value,10) <= parseInt(value_max,10));
	if(value_min==null || value_max==null) ok4 = true; //il confronto col min e max viene bypassato.
	
	if(!ok4){
		alert(elem.name+" non e' nell'intervallo consentito. Il valore minimo consentito vale "+ parseInt(value_min,10) + " Il valore massimo consentito vale "+parseInt(value_max,10));
		return false;
	}

	ok = (ok1 && ok2 && ok3 && ok4); 
	
	return ok;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

Questa funzione valida la correttezza dei campi di una form.
I parametri passati alla funzione sono:
1) l'oggetto form da esaminare
2) un array di oggetti che rapresentano le varie tipologie di campi presenti in un form html


Per esempio, l'oggetto myDate rappresenta un campo che contiene una data, myInteger uno che contiene un intero, myFloat uno che contiene un float, myMail uno che contiene un indirizzo di posta elettronica, myGFA uno che contiene un valore alfabetico, myGFAN uno che contiene un valore alfanumerico.

I vari controlli vengono fatti in sequenza. Prima viene controllata l'obbligatorieta' dei campi, poi la correttezza dei vari tipi di campi della form.
L'algoritmo che effettua i vari controlli e' molto semplice. Per capirlo esaminiamo la parte che effettua
il controllo sulla obbligatorieta'.
Viene fatto un ciclo for in cui si passano in rassegna tutti gli elementi della form. Si controlla che il
generico elemento sia presente nella lista degli oggetti obbligatori e , in tal caso, viene processato da una opportuna funzione.
La stessa procedura viene usata per controllare la correttezza dei dati e dei formati.
La funzione validaForm e' compatibile sia con Internet Explorer che con Netscape.

*/


function validaForm(myform,campi_form){


var campi_date = new Array();
var campi_interi = new Array();
var campi_float = new Array();
var campi_euro = new Array();
var campi_alfabetici = new Array();
var campi_alfanumerici = new Array();
var campi_mail = new Array();
var campi_time = new Array();

//costruisco i vettori che contengono gli oggetti relativi ai vari tipi di campi


for(i=0; i<campi_form.length; i++){

	obj = campi_form[i];
	if(obj.type == "date") campi_date = addToArray(campi_date,obj);
	else if(obj.type == "integer") campi_interi = addToArray(campi_interi,obj);
	else if(obj.type == "float") campi_float = addToArray(campi_float,obj);
	else if(obj.type == "gfa") campi_alfabetici = addToArray(campi_alfabetici,obj);
	else if(obj.type == "gfan") campi_alfanumerici = addToArray(campi_alfanumerici,obj);
	else if(obj.type == "mail") campi_mail = addToArray(campi_mail,obj);
	else if(obj.type == "time") campi_time = addToArray(campi_time,obj);
	else if(obj.type == "euro_italia") campi_euro = addToArray(campi_euro,obj);


}


var lista_par = new Array(campi_date,campi_interi,campi_float,campi_alfabetici,campi_alfanumerici,campi_mail,campi_time,campi_euro);

//array che contiene gli oggetti che rappresentano le date	
var campi_date = lista_par[0];		   

//array che contiene gli oggetti che rappresentano i campi contenenti interi	
var campi_interi = lista_par[1];		   

//array che contiene gli oggetti che rappresentano i campi contenenti float		
var campi_float = lista_par[2];		   

//array che contiene gli oggetti che rappresentano i campi alfabetici	
var campi_alfabetici = lista_par[3];	   
	
//array che contiene gli oggetti che rappresentano i campi alfanumerici	
var campi_alfanumerici = lista_par[4];	  

//array che contiene gli oggetti che rappresentano indirizzi di posta elettronica	
var campi_mail = lista_par[5];

//array che contiene gli oggetti che rappresentano gli orari
var campi_time = lista_par[6];

//array che contiene gli oggetti che rappresentano numeri in formato euro italiano
var campi_euro = lista_par[7];



/* controllo l'obbligatorieta' dei campi */


	for(a=0; a< myform.elements.length; a++){
		oggetto = myform.elements[a];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		exist = cercaCampoObbligatorio(lista_par,nome_campo);
		
		if((tipo_campo =="select-one" || tipo_campo =="select-multiple") && exist){			

			if(!comboIsValorizzato(oggetto)) return false;
			 continue;
			}

		oggetto_valido = (tipo_campo!="hidden" && tipo_campo!="button" && tipo_campo!="reset" && tipo_campo!="image" && tipo_campo!="submit" && tipo_campo!="radio");

		if(oggetto_valido && exist){
			if(!oggettoIsValorizzato(oggetto)) return false;
			
		}
	}


/* controllo la correttezza dei campi di tipo data */

	for(b=0; b< myform.elements.length; b++){
		oggetto = myform.elements[b];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;
		
		obj = cercaOggetto(campi_date,nome_campo);
		if(tipo_campo!="hidden" && obj != null){
			
			if(!validaFormatoData(oggetto,obj.formato,obj.min_value,obj.max_value)){
				oggetto.focus();	
				return false;
			}
			
		}
	}



/* controllo la correttezza dei campi di tipo alfabetico */


	for(c=0; c< myform.elements.length; c++){
		oggetto = myform.elements[c];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_alfabetici,nome_campo);
		
		if(tipo_campo!="hidden" && obj != null){
			
			if(!isName(oggetto.value)){
				alert(nome_campo+" contiene caratteri non validi.");
				oggetto.focus();
				return false;
			}	
			if(oggetto.value.length > obj.max_length ){
				alert(nome_campo+" contiene un numero di caratteri non valido.Non sono ammessi piu' di " + obj.max_length + " caratteri.");
				oggetto.focus();
				return false;
			}							
			
		}
	}



/* controllo la correttezza dei campi di tipo alfanumerico */


	for(c=0; c< myform.elements.length; c++){
		oggetto = myform.elements[c];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_alfanumerici,nome_campo);

		if(tipo_campo!="hidden" && tipo_campo!="select-one" && tipo_campo!="select-multiple" && obj != null){
			
			if(!isAlNum(oggetto.value) && tipo_campo!= "textarea"){
				alert(nome_campo+" contiene caratteri non validi.");
				oggetto.focus();
				return false;
			}				
	
			if(oggetto.value.length > obj.max_length ){
				alert(nome_campo+" contiene un numero di caratteri non valido.Non sono ammessi piu' di " + obj.max_length + " caratteri.");
				oggetto.focus();
				return false;
			}		
		}
	}




/* controllo la correttezza dei campi di tipo integer */


	for(d=0; d< myform.elements.length; d++){
		oggetto = myform.elements[d];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_interi,nome_campo);
		
		if(tipo_campo!="hidden" && obj != null){
			
			if(!validaFormatoInteger(oggetto,obj.min_cifre,obj.max_cifre,obj.min_value,obj.max_value)){
				oggetto.focus();	
				return false;
			}
			
		}
	}




/* controllo la correttezza dei campi di tipo float */


	for(e=0; e< myform.elements.length; e++){
		oggetto = myform.elements[e];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_float,nome_campo);

		if(tipo_campo!="hidden" && obj != null){
			
			if(!validaFormatoFloat(oggetto,obj.cifre_parte_intera,obj.cifre_parte_decimale,obj.min_value,obj.max_value)){
				oggetto.focus();	
				return false;
			}
			
		}
	}


/* controllo la correttezza dei campi di tipo euro */
	
	for(e=0; e< myform.elements.length; e++){
		oggetto = myform.elements[e];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_euro,nome_campo);

		if(tipo_campo!="hidden" && obj != null){
			if(!validaFormatoEuroItalia(oggetto,obj.cifre_parte_intera,obj.cifre_parte_decimale,obj.min_value,obj.max_value)){
				oggetto.focus();	
				return false;
			}
			
		}
	}


/* controllo la correttezza dei campi di tipo e_mail */


	for(f=0; f< myform.elements.length; f++){
		oggetto = myform.elements[f];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;

		obj = cercaOggetto(campi_mail,nome_campo);
		if(tipo_campo!="hidden" && obj != null){
			
			if(oggetto.value!="" && !isEmail(oggetto.value)){
				alert(nome_campo+" contiene caratteri non validi.");
				oggetto.focus();
				return false;
			}						
			
		}
	}


/* controllo la correttezza dei campi di tipo ora */

	for(g=0; g< myform.elements.length; g++){
		oggetto = myform.elements[g];
		nome_campo = oggetto.name;
		tipo_campo = oggetto.type;
		
		obj = cercaOggetto(campi_time,nome_campo);
		if(tipo_campo!="hidden" && obj != null){
			
			if(!validaFormatoTime(oggetto,obj.formato,obj.min_value,obj.max_value)){
				oggetto.focus();	
				return false;
			}
			
		}
	}




	//formToUpperCase(myform); //trasformo i campi della form in maiuscolo
	
	return true;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/*
	Questa funzione effettua un controllo lasco sulla obbligatorieta' dei campi di una 
	form. Restituisce false solo se nessun campo e' valorizzato. 
	Restituisce true altrimenti.	
*/

function controlloObbligLasco(myForm){

	var cont = 0; //conta i campi valorizzati
	
	for(i=0; i < myForm.elements.length; i++){
		field = myForm.elements[i];
		tipo = field.type;
		
		if( (tipo=="text" || tipo=="password" || tipo=="textarea") && field.value!=""){
			
			cont++;			
		}
		
		if(tipo=="select-one" || tipo=="select-multiple"){
			indice = field.selectedIndex;
			valore = field.options[indice].text;
			if(valore != "") { cont++;}
		}	
	} 

	if(cont > 0) return true;
	else {
		alert("Attenzione!\nE' necessario valorizzare almeno un campo");
		return false;
	}
}

///////////////////////////////////////////////////////////////////////////////////////

/*
	Questa funzione converte in maiuscolo tutte le stringhe contenute negli oggetti
	di tipo "text" e "textarea"

	
*/
function formToUpperCase(myForm){

	for(i=0; i< myForm.elements.length; i++){
		obj = myForm.elements[i];
		if(obj.type == "text" || obj.type=="textarea"){
			obj.value = obj.value.toUpperCase();
		}
	}

}

/////////////////////////////////////////////////////////////////////////////////////
/*
Cerca nell'array di stringhe vect la stringa campo.
Ritorna l'indice se la trova, -1 altrimenti

*/

function cercaCampo(vect,campo){

	valid = -1;

	for(k=0; k < vect.length; k++){

		if(vect[k]==campo){
				
			valid = k;
			break;
		}
	}	

	//alert("cercaCampo, campo vale " +campo);
	return valid;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
Cerca nell'array di array 'lista_par' l'oggetto di nome 'name'.
Ritorna true se lo trova, false altrimenti

*/

function cercaCampoObbligatorio(lista_par,name){

//array che contiene gli oggetti che rappresentano le date	
var campi_date = lista_par[0];		   

//array che contiene gli oggetti che rappresentano i campi contenenti interi	
var campi_interi = lista_par[1];		   

//array che contiene gli oggetti che rappresentano i campi contenenti float		
var campi_float = lista_par[2];		   

//array che contiene gli oggetti che rappresentano i campi alfabetici	
var campi_alfabetici = lista_par[3];	   
	
//array che contiene gli oggetti che rappresentano i campi alfanumerici	
var campi_alfanumerici = lista_par[4];	  

//array che contiene gli oggetti che rappresentano indirizzi di posta elettronica	
var campi_mail = lista_par[5];

//array che contiene gli oggetti che rappresentano gli orari
var campi_time = lista_par[6];

//array che contiene gli oggetti che rappresentano numeri in formato euro italiano
var campi_euro = lista_par[7];

	for(k=0; k < campi_date.length; k++){

		if(campi_date[k].name==name && campi_date[k].required){
			return true;	
		}
	}	
	
	for(k=0; k < campi_interi.length; k++){

		if(campi_interi[k].name==name && campi_interi[k].required){
			return true;	
		}
	}	

	for(k=0; k < campi_float.length; k++){

		if(campi_float[k].name==name && campi_float[k].required){
			return true;	
		}
	}	

	for(k=0; k < campi_euro.length; k++){

		if(campi_euro[k].name==name && campi_euro[k].required){
			return true;	
		}
	}

	for(k=0; k < campi_alfabetici.length; k++){

		if(campi_alfabetici[k].name==name && campi_alfabetici[k].required){
			return true;	
		}
	}	



	for(k=0; k < campi_alfanumerici.length; k++){

		if(campi_alfanumerici[k].name==name && campi_alfanumerici[k].required){
			return true;	
		}
	}	



	
	for(k=0; k < campi_mail.length; k++){

		if(campi_mail[k].name==name && campi_mail[k].required){
			return true;	
		}
	}	


	
	for(k=0; k < campi_time.length; k++){

		if(campi_time[k].name==name && campi_time[k].required){
			return true;	
		}
	}	

	return false;

}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
Cerca nell'array di oggetti vect l'oggetto il cui nome e' "name".
Ritorna l'oggetto se lo trova, null altrimenti

*/

function cercaOggetto(vect,name){

	valid = null;

	for(k=0; k < vect.length; k++){

		if(vect[k].name==name){
				
			valid = vect[k];
			break;
		}
	}	

	//alert("cercaCampo, campo vale " +campo);
	return valid;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*

Il parametro obj e' un oggetto a selezione singola o multipla. Viene controllato se e' stata scelta una voce non nulla.
Ritorna true se e' stata fatta una scelta, false altrimenti
*/

function comboIsValorizzato(obj){

	tipo = obj.type;

 if(tipo=="select-one"){ //combo a selezione singola

		//controllo se e' stata selezionata una voce
		var selNum = obj.selectedIndex; //indice dell'opzione selezionata
		var selText = obj.options[selNum].text; //valore dell'opzione selezionata
		if(selText=="" || selText==null){ alert(obj.name + " e' obbligatorio");
		obj.focus();
		return false;
		}
	}

	else if(tipo=="select-multiple"){ //combo a selezione multipla
		//controllo se e' stata selezionata una voce
		var selNum = obj.selectedIndex; //indice dell'opzione selezionata
		
		if(selNum!=-1){ //e' stata selezionata un opzione
			var selText = obj.options[selNum].text;				
			if(selText==""){ //se l'opzione selezionata non e' valorizzata
				alert(obj.name+ " e' obbligatorio");
				obj.focus();	
				return false;
			}
		}
	}
		return true;

}



///////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	 Controlla se e' un numero (intero o decimale). I numeri decimali si assumono con 
	 la parte intera separata da quella decimale tramite un punto (.)
*/


function isNumeric(element) {


	//pattern = /^[0-9]{0,}$/;
	
	//pattern = /^[0-9]{0,}[\.]{0,1}[0-9]{0,}$/ 
	pattern = /^[\-]{0,1}[0-9]{0,}[\.]{0,1}[0-9]{0,}$/ 

	return pattern.test(element.value);
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	 Controlla se e' un numero in formato euro italiano. I numeri decimali si assumono con 
	 la parte intera separata da quella decimale tramite una virgola (,)
*/


function isNumericEuroItalia(element,cpi,cpd) {
		
	var numero = new Array();
	numero = element.value.toString().split(',');
	var pattern;
	var i = 0;
	var stringa = element.value;
	
		
	//controllo che ci sia un solo separatore tra cifre intere e cifre decimali
	conta_virgole = 0;
	for(i=0; i < stringa.length; i++){
		if(stringa.charAt(i) == ',') conta_virgole++;
	}	
	if(conta_virgole > 1){
		 alert(element.name + " deve essere un numero.");	
		 return false;
	}	 
	
	
	//controllo che il primo carattere sia un numero oppure l'operatore unario '-'
	if(numero[0].charAt(0)!='0' && numero[0].charAt(0)!='1' && numero[0].charAt(0)!='2' && 
			numero[0].charAt(0)!='3' && numero[0].charAt(0)!='4' && numero[0].charAt(0)!='5' && 
			numero[0].charAt(0)!='6' && numero[0].charAt(0)!='7' && numero[0].charAt(0)!='8' && 
			numero[0].charAt(0)!='9' && numero[0].charAt(0)!='-'){
				alert(element.name + " deve essere un numero.");
				return false;
		}
	
	//controllo che la parte intera contenga solo numeri oppure punti di separazione delle migliaia
	
	for(i=1; i < numero[0].length; i++){
		if(numero[0].charAt(i)!='0' && numero[0].charAt(i)!='1' && numero[0].charAt(i)!='2' && 
			numero[0].charAt(i)!='3' && numero[0].charAt(i)!='4' && numero[0].charAt(i)!='5' && 
			numero[0].charAt(i)!='6' && numero[0].charAt(i)!='7' && numero[0].charAt(i)!='8' && 
			numero[0].charAt(i)!='9' && numero[0].charAt(i)!='.'){
				alert(element.name + " deve essere un numero.");
				return false;
		}
			
		}
		
	//controllo che la parte decimale contenga solo numeri. 
	
	for(i=0; numero[1]!=null && i < numero[1].length; i++){
		if(numero[1].charAt(i)!='0' && numero[1].charAt(i)!='1' && numero[1].charAt(i)!='2' && 
			numero[1].charAt(i)!='3' && numero[1].charAt(i)!='4' && numero[1].charAt(i)!='5' && 
			numero[1].charAt(i)!='6' && numero[1].charAt(i)!='7' && numero[1].charAt(i)!='8' && 
			numero[1].charAt(i)!='9'){
				alert(element.name + " deve essere un numero.");
				return false;
		}
			
		}
	
	var cifre_pi = contaCifreNumeriche(numero[0]); //numero cifre parte intera
	var cifre_pd = contaCifreNumeriche(numero[1]); //numero cifre parte decimale
	
	//controllo che le cifre intere e quelle decimali rientrano nel range dichiarato
	if(cifre_pi > cpi || cifre_pd > cpd){
		alert(element.name+" non ha il formato numerico corretto. Deve avere al max " + cpi + " cifre intere e al max " + cpd + " cifre decimali.");
		return false;	
	}	
	
			
	//controllo che l'eventuale separatore delle migliaia stia al posto giusto
	if(cifre_pi == 1 && cifre_pd > 0){	
		pattern = /^[\-]{0,1}[0-9]{0,1}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 1 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}$/ 
	}	
	if(cifre_pi == 2 && cifre_pd > 0){	
		pattern = /^[\-]{0,1}[0-9]{0,2}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 2 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}$/ 
	}
	if(cifre_pi == 3 && cifre_pd > 0){	
		pattern = /^[\-]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 3 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}$/ 
	}
	if(cifre_pi == 4 && cifre_pd > 0){	
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 4 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 5 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 5 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 6 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 6 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 7 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 7 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 8 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 8 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 9 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 9 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 10 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 10 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,1}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 11 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 11 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,2}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	else if(cifre_pi == 12 && cifre_pd > 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\,]{0,1}[0-9]{0,}$/ 
	}
	else if(cifre_pi == 12 && cifre_pd == 0){
		pattern = /^[\-]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}[\.]{0,1}[0-9]{0,3}$/ 
	}
	
	if(!pattern.test(element.value)) alert(element.name+" non ha il formato numerico corretto. I separatori delle migliaia sono stati usati impropriamente.");	
	
	return pattern.test(element.value);	
		
}

///////////////////////////////////////////////////////////////////////////////////////

/* Converte in uppercase un campo testo*/

function makeUppercase(field) 
{	
	field.value = field.value.toUpperCase();
}

///////////////////////////////////////////////////////////////////////////////////////

function isName(value) {

	three=/^[a-zA-Z,' ]{0,}$/;
	
	s = new String(value);

	if (s.charAt(0) == ',' || s.charAt(s.length-1) == ',')
		return false;
	return three.test(value);

}
///////////////////////////////////////////////////////////////////////////////////////
function isEmail(string) {

    if (string.search(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/) != -1)
        return true;
    else
        return false;
}
///////////////////////////////////////////////////////////////////////////////////////
function isAlpha(value) {

	three=/^[a-zA-Z]{0,}$/;
	return three.test(value);
}

///////////////////////////////////////////////////////////////////////////////////////
function isAlNum(value) {
	
	three=/^[a-zA-Z0-9,.,+, ,-,',:,;,?,!,$,ò,à,ù,ì,è,é,\,]{0,}$/; 
	
	return three.test(value);
}
///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
	Questa funzione analizza il formato di un orario:

	I parametri di input sono obj che rappresenta il campo(oggetto) di una form e formato che rappresenta la stringa che
	serve a formattare l'orario.
*/

function validaFormatoTime(obj,formato,minval,maxval){


	if(obj.value=="") return true;
	if(!isTime(obj,formato)){ // controllo sulla correttezza del formato
		alert("L'orario non e' nel formato corretto.Deve avere il formato "+formato);
		return false;
	}
	else{
		 if(!isValidTime(obj,formato)){ //controllo sulla validita' dell' orario
			alert("L'orario non e' valido");
			return false;	
		 }		
	}	

	var arrins = new Array();
	var arrmin = new Array();
	var arrmax = new Array();
	arrins = obj.value.toString().split(':');	
	arrmin = minval.toString().split(':');	
	arrmax = maxval.toString().split(':');	

  	min_inseriti = parseInt(arrins[0],10)*60 + parseInt(arrins[1],10);
  	min_min = parseInt(arrmin[0],10)*60 + parseInt(arrmin[1],10);
  	min_max = parseInt(arrmax[0],10)*60 + parseInt(arrmax[1],10);
	
	ok = min_inseriti >= min_min && min_inseriti <= min_max 
	
	if(!ok){
		alert("L'orario non e' nell'intervallo corretto.Deve essere compresa tra " + minval + " e " + maxval);
		return false;
	}
	return true;

}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*
    controlla la correttezza del formato. Il pattern matching viene costruito su tre tipi di formato possibili:
    "hh:mm"
    se viene passato un formato non valido viene lanciato un opportuno messaggio di errore.
    Notare che viene sfruttato il meccanismo delle espressioni regolari.

*/

function isTime(field,formato) {
	

	formato = formato.toLowerCase();	

	if(formato=="hh:mm" || formato=="oo:mm"){
		datePattern = /^[0-9]{1,2}\:[0-9]{1,2}$/;
	}
	else{
		alert("Attenzione!\nErrore nella funzione JavaScript isDate: formato "+formato +" non riconosciuto.");
		return false;
	}	

	return (field.value == "" || datePattern.test(field.value));	
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*

Controlla che l'ora sia corretta

*/

function isValidTime(dateField,formato)
{
	var arr = new Array();

	formato = formato.toLowerCase();	

	if(formato=="hh:mm" || formato=="oo:mm"){
		arr = dateField.value.toString().split(':');	
	}
	else{
		alert("Attenzione!\nErrore nella funzione JavaScript isValidDate: formato "+formato +" non riconosciuto.");
		return false;
	}
	
	
	
	var hour = arr[0];
	var min = arr[1];
	

	if (parseInt(hour,10) > 23 || parseInt(min,10) > 59) return false;
	if(hour.length==1) hour= "0" + hour;
	if(min.length==1) min= "0" + min;
	dateField.value = hour + ":" + min;	
	return (true);
}

////////////////////////////////////////////////////////////////////////////////////////////

//Questa funziona accoda un elemento item all'array vect
function addToArray(vect,item){

	len = vect.length;
	vect[len] = item; 	

	return vect;
}
////////////////////////////////////////////////////////////////////////////////////////////

//Questa funziona elimina gli spazi a sinistra e a destra di una stringa

function trim(str){

			var upper=str.length-1,lower=0;	
			
			for(i=str.length; i>0; i--){
				if(str.substring(i-1,i)!= " "){
					 upper = i;
					 break;	
				}
			}	
			
			for(i=0; i<str.length; i++){
				if(str.substring(i,i+1)!= " "){
					 lower = i ;
					 break;
				}
				
			}

			str = str.substring(lower,upper);
			
			return str;
	
	}

////////////////////////////////////////////////////////////////////////////////////////////
/*
conta il numero di cifre numeriche presenti
in una stringa passata come parametro
*/

function contaCifreNumeriche(stringa){
		
	cont = 0;
	if(stringa == null) return 0;
	
	for(i=0; i<stringa.length; i++){
		if(stringa.charAt(i) == '0' || stringa.charAt(i) == '1' || stringa.charAt(i) == '2' 
			|| stringa.charAt(i) == '3' || stringa.charAt(i) == '4' || stringa.charAt(i) == '5' 
			|| stringa.charAt(i) == '6' || stringa.charAt(i) == '7' || stringa.charAt(i) == '8' 
			|| stringa.charAt(i) == '9'){
		
			cont++;	
		}
	}
	return cont;
}
////////////////////////////////////////////////////////////////////////////////////////////
/*
funzione che prende in input un numero in formato euro italiano
e lo converte nel formato float, in cui la parte intera è separata
dalla decimale da un punto.
*/

function converteEuroFloat(numero_euro){
		
	var ris_pi = "";
		
	if(numero_euro == null || numero_euro == "" ) return numero_euro;
	
	var numero = new Array();
	numero = numero_euro.toString().split(',');
	
	for(i=0; i<numero[0].length; i++){
		if(numero[0].charAt(i) == '0' || numero[0].charAt(i) == '1' || numero[0].charAt(i) == '2' 
			|| numero[0].charAt(i) == '3' || numero[0].charAt(i) == '4' || numero[0].charAt(i) == '5' 
			|| numero[0].charAt(i) == '6' || numero[0].charAt(i) == '7' || numero[0].charAt(i) == '8' 
			|| numero[0].charAt(i) == '9' || numero[0].charAt(i) == '-'){
		
				ris_pi += numero[0].charAt(i);	
		}
	}
	
	return ris_pi + "." + numero[1];
}