//LIBRERIA:

/*
INDICE FILE:
	1) Funzioni di uso generico per il controllo dei campi di un form --> RIGA 139
	2) Gestori evento keypress                                        --> RIGA 339
	3) Gestori evento onFocus					  --> RIGA 434
	4) Motore di Validazione di form basato su regole		  --> RIGA 458
	5) Definizione degli Oggetti Boxregole                            --> RIGA 851
			
*/

//Variabili globali degli script
QuestoSecolo = 2000; //usato per i controlli delle date: se anno è 09 viene inteso come QuestoSecolo+09 =>2009

//Variabili Motore di Validazione
Errori = new Array(); //array che conterrà gli errori da visualizzare
Modo   = "alert";

Dizionario = new Array(); //array dizionario

Dizionario.Italiano			= new Array();
Dizionario.Italiano.header		= "Il form contiene uno o più errori:"
Dizionario.Italiano.start		= "->";
Dizionario.Italiano.field		= " il campo ";
Dizionario.Italiano.checkbox		= " il checkbox ";
Dizionario.Italiano.require		= " è richiesto";
Dizionario.Italiano.minim		= " deve contenere almeno ";
Dizionario.Italiano.massim		= " deve contenere non più di ";
Dizionario.Italiano.minmax		= " e non più di ";
Dizionario.Italiano.chars		= " caratteri";
Dizionario.Italiano.minore		= " deve essere inferiore al campo ";
Dizionario.Italiano.maggiore		= " deve essere superiore al campo ";
Dizionario.Italiano.uguale		= " deve essere uguale al campo ";
Dizionario.Italiano.minoreuguale	= " deve essere uguale o inferiore al campo ";
Dizionario.Italiano.maggioreuguale	= " deve essere uguale o superiore al campo ";
Dizionario.Italiano.diverso		= " deve essere diverso dal campo ";
Dizionario.Italiano.num			= " deve contenere un numero";
Dizionario.Italiano.inte		= " deve contenere un numero intero";
Dizionario.Italiano.check		= " deve essere selezionato";
Dizionario.Italiano.date		= " deve contenere una data";
Dizionario.Italiano.formatDate		= " ( dd-mm-aaaa )";
Dizionario.Italiano.email		= " deve contenere un indirizzo email valido";

Dizionario.Inglese		    	= new Array();		
Dizionario.Inglese.header		= "The following error(s) occured:"
Dizionario.Inglese.start		= "->";
Dizionario.Inglese.field		= " Field ";
Dizionario.Inglese.checkbox		= " Checkbox ";
Dizionario.Inglese.require		= " is required";
Dizionario.Inglese.minim		= " and must consist of at least ";
Dizionario.Inglese.massim		= " and must not contain more than ";
Dizionario.Inglese.minmax		= " and no more than ";
Dizionario.Inglese.chars		= " characters";
Dizionario.Inglese.num			= " and must contain a number";
Dizionario.Inglese.minore		= " must be less than the field ";
Dizionario.Inglese.maggiore		= " must be more than the field ";
Dizionario.Inglese.uguale		= " must be equal to the field ";
Dizionario.Inglese.minoreuguale		= " must be equal or less than the field ";
Dizionario.Inglese.maggioreuguale	= " must be equal or more than the field ";
Dizionario.Inglese.diverso		= " must be different than the field ";
Dizionario.Inglese.inte			= " must be an integer ";
Dizionario.Inglese.check		= " must be checked ";
Dizionario.Inglese.date			= " must be a valid date ";
Dizionario.Inglese.formatDate		= " ( dd-mm-yyyy )";
Dizionario.Inglese.email		= " must contain a valid e-mail address";
Dizionario.Inglese.code			= " wrong verification code";

Dizionario.Tedesco		    	= new Array();		
Dizionario.Tedesco.header		= "die Angaben sind fehlerhaft:"
Dizionario.Tedesco.start		= "->";
Dizionario.Tedesco.field		= " das Kästchen ";
Dizionario.Tedesco.checkbox		= " die Checkbox ";
Dizionario.Tedesco.require		= " wird verlangt";
Dizionario.Tedesco.minim		= " mindestens ";
Dizionario.Tedesco.massim		= " höchstens ";
Dizionario.Tedesco.minmax		= " und nicht mehr als ";
Dizionario.Tedesco.chars		= " Zeichen";
Dizionario.Tedesco.num			= " muss eine Ziffer beinhalten";
Dizionario.Tedesco.minore		= " muss kleiner als das Kästchen sein ";
Dizionario.Tedesco.maggiore		= " muss grösser als das Kästchen sein ";
Dizionario.Tedesco.uguale		= " muss gleich gross wie das Kästchen sein ";
Dizionario.Tedesco.minoreuguale		= " muss gleich oder kleinerer als das Kästchen sein ";
Dizionario.Tedesco.maggioreuguale	= " muss gleich oder grösser als das Kästchen sein ";
Dizionario.Tedesco.diverso		= " muss verschieden als das Kästchen sein ";
Dizionario.Tedesco.inte			= " muss eine ganze Zahl beinhalten ";
Dizionario.Tedesco.check		= " muss angegeben werden ";
Dizionario.Tedesco.date			= " muss ein Datum beinhalten ";
Dizionario.Tedesco.formatDate		= " ( dd-mm-yyyy )";
Dizionario.Tedesco.email		= " muss eine korrekte Email Adresse beinhalten";

Dizionario.Francese		    	= new Array();		
Dizionario.Francese.header		= "Le formulaire contient une ou plusieurs erreurs:"
Dizionario.Francese.start		= "->";
Dizionario.Francese.field		= " le champ ";
Dizionario.Francese.checkbox		= " la boite ";
Dizionario.Francese.require		= " iil vous est demandé";
Dizionario.Francese.minim		= " doit contenir au moins ";
Dizionario.Francese.massim		= " ne doit pas être plus que ";
Dizionario.Francese.minmax		= " et pas plus que ";
Dizionario.Francese.chars		= " caractères";
Dizionario.Francese.num			= " dois contenir un numéro";
Dizionario.Francese.minore		= " doit être inférieur au champ ";
Dizionario.Francese.maggiore		= " doit être supérieur au champ ";
Dizionario.Francese.uguale		= " doit être égal au champ ";
Dizionario.Francese.minoreuguale	= " doit être égal au champ ou inférieur au champ ";
Dizionario.Francese.maggioreuguale	= " doit être égal au champ ou supérieur au champ ";
Dizionario.Francese.diverso		= " doit être différent du champ ";
Dizionario.Francese.inte		= " doit contenir un chiffre entier ";
Dizionario.Francese.check		= " must be checked ";
Dizionario.Francese.date		= " doit contenir une date valide ";
Dizionario.Francese.formatDate		= " ( dd-mm-yyyy )";
Dizionario.Francese.email		= " doit contenir une adresse email valide";

Dizionario.Spagnolo		    	= new Array();		
Dizionario.Spagnolo.header		= "La forma tiene una o màs faltas:"
Dizionario.Spagnolo.start		= "->";
Dizionario.Spagnolo.field		= " El campo ";
Dizionario.Spagnolo.checkbox		= " El checkbox ";
Dizionario.Spagnolo.require		= " obligatorio";
Dizionario.Spagnolo.minim		= " debe contener por lo menos ";
Dizionario.Spagnolo.massim		= " no puede contener màs de ";
Dizionario.Spagnolo.minmax		= " y no màs de ";
Dizionario.Spagnolo.chars		= " caracteres";
Dizionario.Spagnolo.num			= " debe contener un numero";
Dizionario.Spagnolo.minore		= " debe ser inferior al campo ";
Dizionario.Spagnolo.maggiore		= " tiene que ser superior al campo ";
Dizionario.Spagnolo.uguale		= " debe ser igual al campo ";
Dizionario.Spagnolo.minoreuguale	= " be ser igual o inferior al campo ";
Dizionario.Spagnolo.maggioreuguale	= " debe ser igual o superior al campo ";
Dizionario.Spagnolo.diverso		= " e ser diverso del campo ";
Dizionario.Spagnolo.inte		= " debe contener un numero entiero ";
Dizionario.Spagnolo.check		= " debe ser seleccionado ";
Dizionario.Spagnolo.date		= " debe contener una data ";
Dizionario.Spagnolo.formatDate		= " ( dd-mm-yyyy )";
Dizionario.Spagnolo.email		= " debe contener una cuenta de correo valida";


/**************************************************************************************************
 *  FUNZIONI DI USO GENERICO PER IL CONTROLLO DEI CAMPI DI UN FORM
 *  parseDate(Stringa)			-> trasfroma una stringa del formato giorno/mese/anno in un oggetto Date
 *  DateCompare(date1,date2)	        -> confronta due oggetti date: restituisce 1 se date1 è maggiore, 0 se uguali e 2 se date1 è minore
 *  isDate(Stringa)			-> controlla se Stringa è una data valida
 *  isNumber(Stringa)			-> controlla se Stringa è un numero reale o intero
 *  isInteger(Stringa)			-> controlla se Stringa è un intero
 *  isEmail(Stringa)			-> controlla se Stringa è una email valida (.it /.com ma non .org... )
 *  isChecked(CheckBox)			-> controlla se la checkbox è selezionata
 *  isNull(Input)			-> controlla se il tag value di Input è nullo
 *  le funzioni isX restituiscono true se si verificano, false altrimenti.
 */


/*
 * Funzione che trasforma una stringa di formato dd/mm/aaaa o d/m/aa o dd/m/aa etc.. in una data
 */
function parseDate(Data)
{
   obj=Data;
    next=0;
     gg=obj.substr(0,2);
	 next=3;
	 if(isNaN(gg))
	 {
	   gg=obj.substr(0,1);
	   next = 2;
	 }
     mm=obj.substr(next,2);
 	 if(isNaN(mm)){
		 mm=obj.substr(next,1);
		 next +=2;
	 }
	 else
	 {
	 		 next+=3;
	 }
     aa=obj.substr(next,4);
	 if(isNaN(aa)) aa=obj.substr(next,2);
	 aa = parseInt(aa);
	if(aa<=99) aa+=QuestoSecolo;
      
   return (new Date(aa,mm-1,gg));
}


/*
 * Funzione che confronta due date: restituisce 0 se sono uguali
 * 1 se la prima è maggiore
 * 2 se la prima è minore
 */

function DateCompare(Data1,Data2)
{
	anno1 = Data1.getFullYear();
	anno2 = Data2.getFullYear();
	
	if(anno1 > anno2 )	return 1;
	if(anno1 == anno2)
	{
		mese1 = Data1.getMonth() -1;
		mese2 = Data2.getMonth() -1;
		if(mese1 > mese2 )
							return 1;
		if( mese1 == mese2)
		{
			giorno1 = Data1.getDate();
			giorno2 = Data2.getDate();
			if(giorno1>giorno2) return 1;
			if(giorno1 == giorno2 ) return 0;
		}
	}
	return 2;
}


/*
 * Funzione che verifica se una data è corretta
 * Suppone che la data sia nella forma numerica: cioé dd/mm/aaaa o d-m-aa o dd.mm.aaaa
 */
function isDate(Data)
{
	obj=Data;
    next=0;
    gg=obj.substr(0,2);
	next=3;
	 if(isNaN(gg))
	 {
	   gg=obj.substr(0,1);
	   next = 2;
	 }
     mm=obj.substr(next,2);
 	 if(isNaN(mm)){
		 mm=obj.substr(next,1);
		 next +=2;
	 }
	 else
	 {
	 		 next+=3;
	 }
     aa=obj.substr(next,4);
	 if(isNaN(aa)) aa=obj.substr(next,2);

	anno = parseInt(aa);
	if(anno<=99) anno+=QuestoSecolo;
   
	
    dataTemporanea = new Date(anno,mm-1,gg);
 	giornoTemporaneo = dataTemporanea.getDate();
	meseTemporaneo = dataTemporanea.getMonth()+1;
	annoTemporaneo = dataTemporanea.getFullYear();
	
	if(parseInt(giornoTemporaneo)!= gg )	return false;
	if(parseInt(meseTemporaneo) != mm ) return false;
	if(parseInt(annoTemporaneo)!= anno) return false;
  
    return true;
}


/* 
 * Funzione che verifica se una email è valida
 * Non accetta indirizzo on dominio principala maggiore di 3 caratteri es: ciao@prova.geco
 * geco non riconosciuto.
 */
function isEmail(Email)
{
  if (window.RegExp) {
		var nonvalido = "(@.*@)|(\\.\\.)|(@\\.)|(\\.@)|(^\\.)";
		var valido = "^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
    
		var regnv = new RegExp(nonvalido);
		var regv = new RegExp(valido);
    
		if (!regnv.test(Email) && regv.test(Email))
				return true;
    
		return false;
	}
  else
	{
		if(Email.indexOf("@") >= 0)
				return true;
		return false;
  	}
 }
 
 
/* *
 * Funzione che verifica se una checkbox è checked
 *
 */
function isChecked(checkbox)
{
	return checkbox.checked;
}


/* 
 * Funzione che verifica se un campo è vuoto
 *
 */
function isNull(input)
 {
	 if (input.value) { return true;}
	 return false;
 }
 
 
/*
 * Funzione che verifica se una stringa è un numero reale
 * min e massimo sono gli intervalli (opzionale)
 */
function isNumber(numero,minimo,massimo)
{
	if(isNaN(numero)) return false;
	numero = parseFloat(numero);
	if((minimo) && numero<minimo ) return false;
	if((massimo) && numero>massimo ) return false;
	
	return true;
}


/*
 * Funzione che verifica se una stringa è un intero
 * min e massimo sono gli intervalli (opzionale)
 */
function isInteger(numero,minimo,massimo)
{
	if( (numero.indexOf(".")!=-1) ) return false;
	numero = parseInt( numero );
	if (isNaN(numero)  ) return false;
	if((minimo) && numero<minimo ) return false;
	if((massimo) && numero>massimo ) return false;

	return true;
}


/**************************************************************************************************
 * GESTORI DEL METODO KeyPress
 * limitano il tipo di caratteri da inserire in un campo.
 * utilizzo : <input name="numeroTelefono" onkeypress()="return funzione;">
 * 
 * soloInteri(this)	 	-> inserire solo numeri interi
 * soloData(this) 		-> solo caratteri per una data (numeri e / e - )
 * soloNumeri(this)		-> solo numeri interi ( numeri e . )
 */
 
 
/*
 * permette l'inserimento di solo caratteri numerici
 */
function soloInteri(campo, event)
{

	var tasto,carattereTasto;
	if (window.event) //Modello ad eventi IE
	tasto = window.event.keyCode;
	else if (event) //Modello ad eventi NN
	tasto = event.which;
	else return true;
	carattereTasto = String.fromCharCode(tasto);// verifica tasti particolari tipo canc, invio, ...
	if ((tasto==null) || (tasto==0) || (tasto==8) ||(tasto==9) || (tasto==13) || (tasto==27) )
	{
	  return true;
	}
	else if ((("0123456789").indexOf(carattereTasto) > -1))
	{
     return true;
	}
	else
	{
	return false;
	}
}


/*
 * permette l'inserimento di solo caratteri per una data
 */
function soloData(campo, event)
{

	var tasto,carattereTasto;
	if (window.event) //Modello ad eventi IE
	tasto = window.event.keyCode;
	else if (event) //Modello ad eventi NN
	tasto = event.which;
	else return true;
	carattereTasto = String.fromCharCode(tasto);// verifica tasti particolari tipo canc, invio, ...
	if ((tasto==null) || (tasto==0) || (tasto==8) ||(tasto==9) || (tasto==13) || (tasto==27) )
	{
	  return true;
	}
	else if ((("0123456789-/").indexOf(carattereTasto) > -1))
	{
     return true;
	}
	else
	{
	return false;
	}
}


/*
 * permette l'inserimento di solo caratteri per un numero reale o intero.
 */
function soloNumeri(campo, event)
{

	var tasto,carattereTasto;
	if (window.event) //Modello ad eventi IE
	tasto = window.event.keyCode;
	else if (event) //Modello ad eventi NN
	tasto = event.which;
	else return true;
	carattereTasto = String.fromCharCode(tasto);// verifica tasti particolari tipo canc, invio, ...
	if ((tasto==null) || (tasto==0) || (tasto==8) ||(tasto==9) || (tasto==13) || (tasto==27) )
	{
	  return true;
	}
	else if ((("0123456789.").indexOf(carattereTasto) > -1))
	{
     return true;
	}
	else
	{
	return false;
	}
}


/**************************************************************************************************************************************
 * GESTORI DEL METODO onFocus
 * limitano il tipo di caratteri da inserire in un campo.
 * utilizzo : <input name="numeroTelefono" onFocus()="return funzione;">
 * 
 * seleziona(this)	 	-> seleziona tutto il contenuto del campo di testo
 * azzera(this)			-> cancella il contenuto del campo di testo
 */
 
 
function seleziona(input)
{
	input.focus();
	input.select();
	return true;
}

function azzera(input)
{
	input.value = "";
	return true;
}


/**************************************************************************************************************************************
 *  MOTORE DI VALIDAZIONE BASATO SU REGOLE : FUNZIONI
 *
 */
 
/*
 * funzione per la validazione di un form
 *
 * i parametri sono 1:
 * Modulo -> Modulo da validare (eventualmente)
 *
 * es: <form name="mod" method="get" onSubmit="return Controlla(this);">
 */

 
function Controlla(Modulo)	
{
	BoxRegola = eval("Box_"+ Modulo.name);
	//dopo avere creato un riferimento al mio box di regole

	//passo al controllo delle RegoleSemplici
if(BoxRegola)
{
	for(i=0;i< eval(BoxRegola.RegoleSemplici.length); i++ )
		{
		  var Regola = BoxRegola.RegoleSemplici[i];
		  var Campo = eval("Modulo."+Regola.NomeCampo);
		  
		  //ottenuta la Regola e il campo ad essa associata passo alla verifica
		  switch(Regola.TipoCampo)
		  {
			  case "testo": 	ControllaTesto(Regola,Campo); 
			  					break;
			  case "numero": 	ControllaNumero(Regola,Campo);
			  					break;
			  case "intero":	ControllaIntero(Regola,Campo);
			  					break;
			  case "email" :	ControllaEmail(Regola,Campo);
			  					break;
			  case "data":		ControllaData(Regola,Campo);
			  					break;
			  case "checkbox":	ControllaCheckBox(Regola,Campo);
			  					break;
		  }
		}

	//passo al controllo delle RegoleComposte
	for(i=0;i< eval(BoxRegola.RegoleComposte.length); i++ )
		{
			var Regola = BoxRegola.RegoleComposte[i];
			var Flag = true;
			
			for(j=0;j< eval(BoxRegola.RegoleSemplici.length); j++ )
			{
				var RegolaTemporanea = BoxRegola.RegoleSemplici[i];
				if(RegolaTemporanea.NomeCampo == Regola.NomeCampo1 && RegolaTemporanea.Richiesto==false) Flag = false;
				if(RegolaTemporanea.NomeCampo == Regola.NomeCampo2 && RegolaTemporanea.Richiesto==false) Flag = false;
			}
		 	
		 	if(Flag)
			{
				var Campo1 = eval("Modulo."+Regola.NomeCampo1);
				var Campo2 = eval("Modulo."+Regola.NomeCampo2);
				ControllaRegolaComposta(Regola,Campo1,Campo2);
			}
		}
	
	//controllo se ci sono errori nell'array.
	if( (Errori.length) != 0 )
	{
		VisualizzaErrori(Errori,Modo);
		Errori = new Array();
		return false
	}
	
	else
	{
		return true;
	}
}
 return true;
}


/*
 * funzione per il controllo della visualizzazione degli errori
 */
function VisualizzaErrori(Errori,Modo)
{
	Messaggio = Dizionario[LinguaPagina].header;
	
	if(Modo == "alert")
	{
		Messaggio +="\n";
		for(i=0;i<eval(Errori.length);i++)
		{
			Messaggio += Errori[i] + "\n";
		}
		alert(Messaggio);
	}
}


/*
 * funzione per il controllo di un campo di tipo testo
 */
function ControllaTesto(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];

	if(Regola.Richiesto == true && Campo.value == "" )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.require; 
		Flag = false;
	}

	if( (Regola.Minimo) && Campo.value.length < Regola.Minimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.minim + Regola.Minimo + Termini.chars;;
		Flag = false;
	}
	
	if( (Regola.Massimo) && Campo.value.length > Regola.Massimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.massim + Regola.Massimo + Termini.chars;
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
	
	return Flag
}


/*
 * funzione per il controllo di un campo di tipo Numero
 */
function ControllaNumero(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];
 	
	if(Regola.Richiesto == true && Campo.value == "" )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.require; 
		Flag = false;
	}
	
	if( Campo.value!="" && isNaN(Campo.value) )
	{
		 Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.num; 
		 Flag = false;
	}

	if( !(isNaN(Campo.value)) && (Regola.Minimo) && parseFloat(Campo.value)< Regola.Minimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.minim + Regola.Minimo;
		Flag = false;
	}
	
	if( !(isNaN(Campo.value)) && (Regola.Massimo) && parseFloat(Campo.value) > Regola.Massimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.massim + Regola.Massimo;
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
	
	return Flag
}


/*
 * funzione per il controllo di un campo di tipo Intero
 */
function ControllaIntero(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];
 	
	if(Regola.Richiesto == true && Campo.value == "" )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.require; 
		Flag = false;
	}
	
	if( Campo.value!="" && ( isNaN(Campo.value) || (Campo.value.indexOf(".")!=-1) ) )
	{
		 Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.inte; 
		 Flag = false;
	}

	if( !(isNaN(Campo.value)) && (Regola.Minimo) && parseInt(Campo.value) < Regola.Minimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.minim + Regola.Minimo;
		Flag = false;
	}
	
	if( !(isNaN(Campo.value)) && (Regola.Massimo) && parseInt(Campo.value) > Regola.Massimo )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.massim + Regola.Massimo;
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
	
	return Flag
}


/*
 * funzione per il controllo di un campo di tipo CheckBox
 */
function ControllaCheckBox(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];
 	
	if(Regola.Richiesto == true && Campo.checked != true )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.checkbox + Campo.title + Termini.check; 
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
	
	return Flag
}


/*
 * funzione per il controllo di un campo di tipo data
 */
function ControllaData(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];
 	
	if(Regola.Richiesto == true && Campo.value=="" )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.date + Termini.formatDate;
		Flag = false;
	}	
	else if( Campo.value!= "" && !( isDate(Campo.value)) )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.date + Termini.formatDate; 
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
}


/*
 * funzione per il controllo di un campo di tipo email
 */
function ControllaEmail(Regola,Campo)
{
	Flag = true;
	Termini = Dizionario[LinguaPagina];
 	
	if(Regola.Richiesto == true && Campo.value=="" )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.email;
		Flag = false;
	}	
	else if( Campo.value!= "" && !( isEmail(Campo.value)) )
	{
		Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.email; 
		Flag = false;
	}
	// if(condizione)
	//{
	// Flag = false;
	//}
}


/*
 * funzione per il controllo di una regola composta
 */
function ControllaRegolaComposta(Regola,Campo1,Campo2)
{
	Termini = Dizionario[LinguaPagina];
	Flag = true;
	var valore1;
	var valore2;

	if(Regola.TipoCampo == "numero" || Regola.TipoCampo == "int" ) 
	{
		valore1 = parseFloat(Campo1.value);
		valore2 = parseFloat(Campo1.value);
	}
	else if(Regola.TipoCampo == "data")
		{
			valore1 = parseDate(Campo1.value);
			valore2 = parseDate(Campo2.value);
		}
	else {
			valore1 = Campo1.value;
			valore2 = Campo2.value;
		 }
	
	switch(Regola.Interazione)
	{
			case "<":	if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp!=2)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.minore + Campo2.title;
								}
							}
							else if(valore1>=valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.minore + Campo2.title;
							}
							break;
							
			case ">":	if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp!=1)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.maggiore + Campo2.title;
								}
							}
							else if(valore1<=valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.maggiore + Campo2.title;
							}
							break;

			case "==" : if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp!=0)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.uguale + Campo2.title;
								}
							}
							else if(valore1!=valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.uguale + Campo2.title;
							}
							break;
			case "<=" : if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp==1)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.minoreuguale + Campo2.title;
								}
							}
							else if(valore1>valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.minoreuguale + Campo2.title;
							}
							break;
			case ">=" :if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp==2)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.maggioreuguale + Campo2.title;
								}
							}
							else if(valore1<valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.maggioreuguale + Campo2.title;
							}
							break;
			case "!=" : if(Regola.TipoCampo == "data")
							{
								temp = DateCompare(valore1,valore2);
								if(temp==0)
								{
									Flag = false;
									Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.diverso + Campo2.title;
								}
							}
							else if(valore1==valore2)
							{
								Flag = false;
								Errori[eval(Errori.length)] =  Termini.start + Termini.field + Campo1.title + Termini.diverso + Campo2.title;
							}
							break;
	}
	return Flag;
}


/*************************************************************************************************************************************
 * DEFINIZIONE DEGLI OGGETTI BOXREGOLE E REGOLA SEMPLICE E REGOLA COMPOSTA
 */

/*
 * costruttore per l'oggetto BoxRegole
 * l'oggetto BoxRegole contiene le regole che devono valere
 * per il form di nome NomeForm
 *
 * esempio: var x = new BoxRegole("form");
 */
 
 
function BoxRegole( NomeForm )
{
	this.NomeForm = NomeForm;
	this.RegoleSemplici = new Array();
	this.RegoleComposte = new Array();
	//definizione metodi
	this.AggiungiRegolaSemplice = AggiungiRegolaSemplice ;
	this.RimuoviRegolaSemplice = RimuoviRegolaSemplice;
	this.AggiungiRegolaComposta = AggiungiRegolaComposta;
	this.RimuoviRegolaComposta = RimuoviRegolaComposta;
}


/*
 * costruttore per l'oggetto RegolaSemplice
 * l'oggetto RegolaSemplice contiene le informazioni di un campo di un form.
 * Queste informazioni vengono utilizzate dal motore di validazione per verificare 
 * il valore del campo .
 *
 * I parametri del costruttore sono 4
 * NomeCampo -> il nome del campo (attributo name ).
 * TipoCampo -> la tipologia del campo. Valori che dipendono dal motore di validazione.
 * Richiesto -> è un booleano: accetta valori (true e false): indica se il campo può
 *              essere nullo,vuoto o no.
 * Minimo	 -> numero minimo di caratteri che deve contenere (0 per non controllare)
 * Massimo   -> numero massimo di caratteri che deve contenere (0 per non controllare)
 * <input name="campo" type="text" value=""></input>
 * esempio: var x = new RegolaSemplice("campo","testo",false,-1);
 */

function RegolaSemplice(NomeCampo,TipoCampo,Richiesto,Minimo,Massimo)
{
	this.NomeCampo = NomeCampo;
	this.TipoCampo = TipoCampo;
	
	this.Richiesto = Richiesto;
	this.Minimo = Minimo;
	this.Massimo = Massimo;
	
}


/*
 * costruttore per l'oggetto RegolaComposta
 * l'oggetto RegolaComposta contiene le informazioni che descrivono l'interazione
 * di due campi di un form
 *
 * I parametri del costruttore sono 4
 * NomeCampo1 -> il nome del 1 campo
 * NomeCampo2 -> il nome del 2 campo
 * TipoCampo  -> la tipologia del 1 campo.I Valori dipendono dal motore di validazione. 
 * Interazione -> la tipologia di interazione.
 *				  I Valori dipendono dal motore di validazione. 
 *
 * <input name="campo" type="text" value=""></input>
 * <input name="campo2" type="text" value=""></input>
 * esempio: var x = new RegolaComposta("campo","campo2","testo","testo","escludi");
 * 							campo1 esclude il campo2
 */


function RegolaComposta(NomeCampo1,NomeCampo2,TipoCampo,Interazione)
{
	this.NomeCampo1 = NomeCampo1;
	this.NomeCampo2 = NomeCampo2;

	this.TipoCampo = TipoCampo;
	
	this.Interazione = Interazione;
}


/*
 * funzione per aggiungere una regola semplice ad un BoxRegole.
 *
 * i parametri sono 1:
 * 
 * RegolaSemplice -> RegolaSemplice
 */
 
 
function AggiungiRegolaSemplice(RegolaSemplice)
{
		nomeCampo = RegolaSemplice.NomeCampo;
		posizioneMassima = eval( this.RegoleSemplici.length );
		posizioneRegola = -1;
		
		for( indice = 0; indice < posizioneMassima; indice ++ )
			{
				 var Regola = this.RegoleSemplici[ indice ];
				 if( Regola.NomeCampo == nomeCampo )
								{		posizioneRegola = indice;	}
			}
			
		if( posizioneRegola == -1 )
			{
					posizione = eval(this.RegoleSemplici.length);
						RegolaSemplice.Posizione = posizione;
					  this.RegoleSemplici[posizione] = RegolaSemplice;
				return true;
			}
			return false;
}


/* funzione per rimuovere una regola semplice da un BoxRegole
 * I parametri sono 1:
 * nomeCampo -> nome del campo da cui eliminare la regola semplice
 */
 function RimuoviRegolaSemplice( nomeCampo )
 {
		posizioneMassima = eval( this.RegoleSemplici.length );
		posizioneRegola = -1;
		
		for( indice = 0; indice < posizioneMassima; indice ++ )
			{
				 var Regola = this.RegoleSemplici[ indice ];
				 if( Regola.NomeCampo == nomeCampo )
								{
									posizioneRegola = indice;
									indice = posizioneMassima;
								}
			}
			
		if( posizioneRegola == -1 )	{ return false;	}
		
		while( posizioneRegola < posizioneMassima )
			{
				if( ( posizioneRegola +1 ) < posizioneMassima )
						{		this.RegoleSemplici[ posizioneRegola ] = eval( this.RegoleSemplici[ posizioneRegola+1 ] );	}
				posizioneRegola++;
			}
			
		this.RegoleSemplici.length --;

		return true;
 }
 

 /* funzione per rimuovere una regola composta da un BoxRegole
 * I parametri sono 2:
 * nomeCampo1 -> nome del campo 1
 * nomeCampo2 -> nome del campo 2 da cui eliminare la regola composta con campo 1
 */
 function RimuoviRegolaComposta( nomeCampo1, nomeCampo2 )
 {
		posizioneMassima = eval( this.RegoleComposte.length );
		posizioneRegola = -1;
		
		for( indice = 0; indice < posizioneMassima; indice ++ )
			{
				 var Regola = this.RegoleComposte[ indice ];
				 if( Regola.NomeCampo1 == nomeCampo1 && Regola.NomeCampo2 == nomeCampo2 )
								{
									posizioneRegola = indice;
									indice = posizioneMassima;
								}
			}
			
		if( posizioneRegola == -1 )	{ return false;	}
		
		while( posizioneRegola < posizioneMassima )
			{
				if( ( posizioneRegola +1 ) < posizioneMassima )
						{		this.RegoleComposte[ posizioneRegola ] = eval( this.RegoleComposte[ posizioneRegola+1 ] );	}
				posizioneRegola++;
			}
			
		this.RegoleComposte.length --;
		return true;
 }
 

/*
 * funzione per aggiungere una regola composta ad un BoxRegole.
 *
 * i parametri sono 1:
 * RegolaComposta -> RegolaComposta
 */
function AggiungiRegolaComposta(RegolaComposta)
{
		posizioneMassima = eval( this.RegoleComposte.length );
		posizioneRegola = -1;
		nomeCampo1 = RegolaComposta.NomeCampo1;
		nomeCampo2 = RegolaComposta.NomeCampo2;
		
		for( indice = 0; indice < posizioneMassima; indice ++ )
			{
				 var Regola = this.RegoleComposte[ indice ];
				 if( Regola.NomeCampo1 == nomeCampo1 && Regola.NomeCampo2 == nomeCampo2 )
								{	posizioneRegola = indice;		}
			}
			
		if( posizioneRegola == -1 )
			{
				posizione = eval(this.RegoleComposte.length);
				  this.RegoleComposte[posizione] = RegolaComposta;
				return true;
			}
		return false;
}