//LIBRERIA: libreriajs_draven.js - data: 20/07/2010


/**************************************************************************************************************************************
 * 0. Variabili globali e Dizionari
*/
	
/*	0.1	Usato per i controlli delle date: se anno è 09 viene inteso come QuestoSecolo+09 =>2009
 *
*/
	QuestoSecolo = 2000;
	
/*	0.2	Array che conterra gli errori da visualizzare ( Validatore )
*/	
	Errori = new Array();
	
/*	0.3 Metodo di output del validatore ( "alert" è tramite messaggi di finestra modale )	
*/	
	Modo = "alert";			

/*	0.4 Matrice che contiene le tipologie di carte di credito e le informazioni per verificarne la validita
*/
	arrayCard = new Array();	
	
	arrayCard[ 0 ] = new Array("AE","34,37","15");
	arrayCard[ 1 ] = new Array("VI","4","13,16");
	arrayCard[ 2 ] = new Array("CS","4","16");
	arrayCard[ 3 ] = new Array("MC","51,52,53,54,55","15,16");
	arrayCard[ 4 ] = new Array("EC","51,52,53,54,55","16");
	arrayCard[ 5 ] = new Array("DC","30,36,38","14");
	arrayCard[ 6 ] = new Array("CB","30,36,38","14");
	arrayCard[ 7 ] = new Array("JC","3088,3096,3112,3158,3337,3528","16");
	arrayCard[ 8 ] = new Array("DI","6011","16");
	arrayCard[ 9 ] = new Array("MA","5020,5038,6304,6759","16,18");
	
/*	Dizionario in Italiano
*/	
	Dizionario = new Array();
	
	Dizionario.Italiano	= new Array();
	Dizionario.Italiano.header				= "Il form contiene uno o pi\xF9 errori:"
	Dizionario.Italiano.start				= "->";
	Dizionario.Italiano.field				= " il campo ";
	Dizionario.Italiano.checkbox			= " il checkbox ";
	Dizionario.Italiano.require				= " \xE8 richiesto";
	Dizionario.Italiano.minim				= " deve contenere almeno ";
	Dizionario.Italiano.massim				= " deve contenere non pi\xF9 di ";
	Dizionario.Italiano.minmax				= " e non pi\xF9 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.Italiano.lunghezzacc 		= "Il numero di carta di credito ha una lunghezza invalida";
	Dizionario.Italiano.numerocc 			= "Numero di carta di credito errato";
	
/*	Dizionario in Inglese
*/
	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.lunghezzacc 			= "The length of the credit card number is incorrect";
	Dizionario.Inglese.numerocc 			= "The number of the credit card is invalid";

/*	Dizionario in Tedesco
*/
	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.Tedesco.lunghezzacc 			= "The length of the credit card number is incorrect";
	Dizionario.Tedesco.numerocc 			= "The number of the credit card is invalid";
	
/*	Dizionario in Francese
*/
	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\xE9";
	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\xE9ro";
	Dizionario.Francese.minore				= " doit être inf\xE9rieur au champ ";
	Dizionario.Francese.maggiore			= " doit être sup\xE9rieur au champ ";
	Dizionario.Francese.uguale				= " doit être \xE9gal au champ ";
	Dizionario.Francese.minoreuguale		= " doit être \xE9gal au champ ou inf\xE9rieur au champ ";
	Dizionario.Francese.maggioreuguale		= " doit être \xE9gal au champ ou sup\xE9rieur au champ ";
	Dizionario.Francese.diverso				= " doit être diff\xE9rent 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.Francese.lunghezzacc 		= "The length of the credit card number is incorrect";
	Dizionario.Francese.numerocc 			= "The number of the credit card is invalid";
	
/*	Dizionario in Spagnolo
*/
	Dizionario.Spagnolo = new Array();
	Dizionario.Spagnolo.header				= "La forma tiene una o m\xE0s 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\xE0s de ";
	Dizionario.Spagnolo.minmax				= " y no m\xE0s 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";
	Dizionario.Spagnolo.lunghezzacc 		= "The length of the credit card number is incorrect";
	Dizionario.Spagnolo.numerocc			= "The number of the credit card is invalid";

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

/**************************************************************************************************************************************
 *  1. FUNZIONI DI USO GENERICO PER IL CONTROLLO DEI CAMPI DI UN FORM
 
 *  1.1  ValidNumberMod10( cardNumber )
	Verifica se il numero di carta di credito è valida tramite controllo modulo 10
 *  1.2  CardLenght(cardNumber,cardType)
	Verifica che il codice della carta di credito sia lungo quanto richiesto dal tipo di carta
 *  1.3  ValidNumber( cardNumber, cardType)
	Verifica che il numero di carta di credito sia valida ( prende come input il numero e il tipo di carta )
 *  1.4  parseDate(Stringa)
	Trasfroma una stringa del formato giorno/mese/anno in un oggetto Date
 *  1.5  DateCompare(date1,date2)
	Confronta due oggetti date : restituisce 1 se date1 è maggiore, 0 se uguali e 2 se date1 è minore
 *  1.6  isDate(Stringa)
	Controlla se Stringa è una data valida. Si suppone che la data sia nella forma numerica: dd/mm/aaaa o d-m-aa o dd.mm.aaaa
 *  1.7  isNumber(numero,minimo,massimo)
	Controlla se Stringa è un numero reale o intero. Minimo e massimo sono gli intervalli (opzionale)
 *  1.8  isInteger(Stringa)
	Controlla se Stringa è un intero. Minimo e massimo sono gli intervalli (opzionale)
 *	1.9  isEmail(Stringa)
	Controlla se Stringa è una email valida
 *  1.10 isChecked(CheckBox)
	Controlla se un checkbox è checked
 *  1.11 isNull(Input)
	Controlla se il tag value di Input è nullo
 *
 * 	Le funzioni isX restituiscono true se si verificano, false altrimenti.
 */

/*	1.1 Funzione ValidNumberMod10(cardNumber)
*/
	function ValidNumberMod10(cardNumber) 
	{
		var checkSum = 0;
		var cc = new Array();
			
		for( var i = 0; i < cardNumber.length; i++ ) 
			{ cc[i] = Math.floor(cardNumber.substr(i,1)); }
	
		for( var i = (cardNumber.length % 2); i < cardNumber.length; i+=2 ) 
		{	
			var a = cc[i] * 2;
			
			if ( a >= 10 ) 
			{
				a = ""+a+"";
				b = a.substr(0,1);
				c = a.substr(1,1);
				
				cc[i] = Math.floor(b) + Math.floor(c);	
			}
			 else 
			{	
				cc[i] = a;
			}
		}
		
		for( var i = 0; i < cardNumber.length; i++ ) 
			{ checkSum += Math.floor(cc[i]); }
			
		var validCc = false;
			
		if((checkSum % 10) == 0) validCc = true;

		return validCc;
	}

/*	1.2 Funzione CardLenght(cardNumber,cardType) 
*/
	function CardLenght(cardNumber,cardType) 
	{
		var checkSize = false;

		for( var i=0; i < arrayCard.length; i++ ) 
		{
			if( arrayCard[i][0] == cardType ) 
			{
				var Size = arrayCard[i][2];
				var arraySize = Size.split(",");
				
				for( var s = 0; s < arraySize.length; s++ ) 
				{
					if( arraySize[s] == cardNumber.length ) { checkSize = true; break; }
				}
			}
		}
		
		return checkSize;
	}

/*	1.3 Funzione ValidNumber(cardNumber,cardType)
*/	
	function ValidNumber(cardNumber,cardType) 
	{
		var checkNumber = false;

		for (var i=0; i < arrayCard.length; i++) 
		{
			if(arrayCard[i][0] == cardType ) 
			{
				var Start = arrayCard[i][1];
				var arrayStart = Start.split(",");
				
				for(var s = 0; s < arrayStart.length; s++) 
				{
					if(arrayStart[s] == cardNumber.substr(0,arrayStart[s].length) ) { checkNumber = true; break; }
				}
			}
		}

		return checkNumber;
	}

/*	1.4 Funzione parseDate(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) );
	}

/*	1.5 Funzione DateCompare(Data1,Date2)
*/
	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;
	}
	
/*	1.6  Funzione isDate(Stringa)
*/
	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;
	}
	
/*	1.7 Funzione isNumber(numero,minimo,massimo)
*/
	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;
	}
	
/*	1.8 Funzione isInteger(numero,minimo,massimo)
*/
	function isInteger(numero,minimo,massimo)
	{
		if ( isNaN(numero) || (numero.indexOf(".")!=-1) ) return false;
		
		numero = parseInt(numero);
		
		if( (minimo) && numero < minimo ) return false;
		if( (massimo) && numero > massimo ) return false;

		return true;
	}

/*	1.9 Funzione isEmail(Email)
*/
	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;
		}
	}

/* 1.10 Funzione isChecked
*/
	function isChecked(checkbox)
	{
		return checkbox.checked;
	}
	
/*	1.11 Funzione isNull(input)
*/
	function isNull(input)
	{
		if (input.value) { return true;}
		return false;
	}

/*	1.12 Funzione ControllaCheckBoxes(CampoCheckbox,CampoControllo,Numero)
*/
	function ControllaCheckBoxes(CampoCheckbox,CampoControllo,Numero)
	{
		var ObjCampoCheck = document.getElementById(CampoControllo);
		
		ObjCampoCheck.value = '';
		
		for( i=0; i<= Numero; i++ )
		{
			var ObjCheckBoxes = document.getElementById(CampoCheckbox+'_'+i);
			
			if(ObjCheckBoxes.checked == true) { ObjCampoCheck.value = 'ok'; break; }
		}
	}
	
/**************************************************************************************************************************************
 *  2. MOTORE DI VALIDAZIONE BASATO SU REGOLE : 
 
 *	2.1	Controlla(Modulo)
	Funzione per la validazione di un form i parametri sono:
		Modulo -> Modulo da validare (eventualmente)
		es: <form name="mod" method="get" onSubmit="return Controlla(this);">
 *	2.2 VisualizzaErrori(Errori,Modo)
	Funzione per il controllo della visualizzazione degli errori
 *	2.3 ControllaTesto(Regola,Campo) 
	Funzione per il controllo di un campo di tipo testo
 *	2.4	ControllaNumero(Regola,Campo) 
	Funzione per il controllo di un campo di tipo Numero
 *	2.5 ControllaIntero(Regola,Campo) 
	Funzione per il controllo di un campo di tipo Intero
 *	2.6	ControllaCheckBox(Regola,Campo) 
	Funzione per il controllo di un campo di tipo CheckBox
 *	2.7 ControllaData(Regola,Campo) 
	Funzione per il controllo di un campo di tipo data
 *	2.8 ControllaEmail(Regola,Campo) 
	Funzione per il controllo di un campo di tipo email
 *	2.9 ControllaRegolaComposta(Regola,Campo1,Campo2) 
	Funzione per il controllo di una regola composta
*/

/*	2.1 Funzione Controlla(Modulo)	
*/
	function Controlla(Modulo)
	{
	/*	Creo il riferimento al box regole
	*/
		BoxRegola = eval("Box_"+ Modulo.name);
		
	/*	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;
				}
			}

		/*	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[j];
					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;
	}
	
/*	2.2 VisualizzaErrori(Errori,Modo)
*/
	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);
		}
	}

/*	2.3 ControllaTesto(Regola,Campo)
*/
	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;
		}
		
		return Flag
	}
	
/*	2.4	ControllaNumero(Regola,Campo)
*/
	function ControllaNumero(Regola,Campo)
	{
		Flag = true;
		Termini = Dizionario[LinguaPagina];

		ValoreCampoNumerico = parseFloat( Campo.value );

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

		if( Campo.value!="" &&  ( ValoreCampoNumerico.toString() == "NaN" || isNaN( Campo.value ) ) )
		{
			 Errori[eval(Errori.length)] = Termini.start + Termini.field + Campo.title + Termini.num;
			 Flag = false;
		}

		if( ( ValoreCampoNumerico.toString() != "NaN" || !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( ( ValoreCampoNumerico.toString() != "NaN" || !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;
		}

		return Flag;
	}

/*	2.5 ControllaIntero(Regola,Campo)
*/
	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;
		}
		
		return Flag
	}
	
/*	2.6	ControllaCheckBox(Regola,Campo)
*/
	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;
		}
		
		return Flag
	}
	
/*	2.7 ControllaData(Regola,Campo)
*/
	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;
		}
	}

/*	2.8 ControllaEmail(Regola,Campo)
*/
	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( (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;
		}
	}
	
/*	2.9 ControllaRegolaComposta(Regola,Campo1,Campo2)
*/
	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(Campo2.value);
		}
		else if( Regola.TipoCampo == "data")
		{
			valore1 = parseDate(Campo1.value);
			valore2 = parseDate(Campo2.value);
		}
		else if( Regola.TipoCampo == "carta credito" )
		{
			valore1 = Campo1.value;
			valore2 = Campo2.options.item( Campo2.selectedIndex ).value;
		}
		else
		{
			valore1 = Campo1.value;
			valore2 = Campo2.value;
		}

		switch(Regola.Interazione)
		{
			case "carta credito":
			if ( ! CardLenght( valore1, valore2 ) ) 
			{
				Flag = false;
				Errori[eval(Errori.length)] =  Termini.start + Termini.lunghezzacc;
			}
			else if ( ! ( ValidNumber( valore1, valore2 ) && ValidNumberMod10( valore1 ) ) )
			{
				Flag = false;
				Errori[eval(Errori.length)] =  Termini.start + Termini.numerocc;
			}
			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.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;
	}

/*************************************************************************************************************************************
 * 	3. DEFINIZIONE DEGLI OGGETTI BOXREGOLE E REGOLA SEMPLICE E REGOLA COMPOSTA
 
 *	3.1 BoxRegole( NomeForm ) 
	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");
	
 *	3.2 RegolaSemplice(NomeCampo,TipoCampo,Richiesto,Minimo,Massimo)
	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:
		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);
		
 *	3.3 RegolaComposta(NomeCampo1,NomeCampo2,TipoCampo,Interazione)
	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:
		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
	
 *	3.4 AggiungiRegolaSemplice(RegolaSemplice)
	Funzione per aggiungere una regola semplice ad un BoxRegole.
	I parametri sono:
		RegolaSemplice -> RegolaSemplice
		
 *	3.5 RimuoviRegolaSemplice( nomeCampo ) 
	Funzione per rimuovere una regola semplice da un BoxRegole.
	I parametri sono:
		nomeCampo -> nome del campo da cui eliminare la regola semplice
		
 *	3.6 AggiungiRegolaComposta(RegolaComposta)
	Funzione per aggiungere una regola composta ad un BoxRegole. 
	I parametri sono:
		RegolaComposta -> RegolaComposta
		
 *	3.7	RimuoviRegolaComposta( nomeCampo1, nomeCampo2 )
	Funzione per rimuovere una regola composta da un BoxRegole.
	I parametri sono:
		nomeCampo1 -> nome del campo 1
		nomeCampo2 -> nome del campo 2 da cui eliminare la regola composta con campo 1
 */

/*	3.1 Funzione BoxRegole( NomeForm )
*/
	function BoxRegole( NomeForm )
	{
		this.NomeForm = NomeForm;
		this.RegoleSemplici = new Array();
		this.RegoleComposte = new Array();
		
	/*	Definizione dei metodi
	*/
		this.AggiungiRegolaSemplice = AggiungiRegolaSemplice ;
		this.AggiungiRegolaComposta = AggiungiRegolaComposta;
		this.RimuoviRegolaSemplice = RimuoviRegolaSemplice;
		this.RimuoviRegolaComposta = RimuoviRegolaComposta;
	}
	
/*	3.2 Funzione RegolaSemplice(NomeCampo,TipoCampo,Richiesto,Minimo,Massimo)
*/
	function RegolaSemplice(NomeCampo,TipoCampo,Richiesto,Minimo,Massimo)
	{
		this.NomeCampo = NomeCampo;
		this.TipoCampo = TipoCampo;

		this.Richiesto = Richiesto;
		this.Minimo = Minimo;
		this.Massimo = Massimo;
	}

/*	3.3 Funzione RegolaComposta(NomeCampo1,NomeCampo2,TipoCampo,Interazione)
*/
	function RegolaComposta(NomeCampo1,NomeCampo2,TipoCampo,Interazione)
	{
		this.NomeCampo1 = NomeCampo1;
		this.NomeCampo2 = NomeCampo2;

		this.TipoCampo = TipoCampo;

		this.Interazione = Interazione;
	}
	
/*	3.4 Funzione AggiungiRegolaSemplice(RegolaSemplice)
*/
	function AggiungiRegolaSemplice(RegolaSemplice)
	{
		posizione = eval(this.RegoleSemplici.length);
		
		this.RegoleSemplici[posizione] = RegolaSemplice;
	}

/*	3.5 Funzione RimuoviRegolaSemplice( nomeCampo )
*/
	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;
	}

/*	3.6	Funzione AggiungiRegolaComposta(RegolaComposta)
*/
	function AggiungiRegolaComposta(RegolaComposta)
	{
		posizione = eval(this.RegoleComposte.length);
		this.RegoleComposte[posizione] = RegolaComposta;
	}	
	
/* 3.7	Funzione RimuoviRegolaComposta( nomeCampo1, nomeCampo2 )
*/
	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;
	}
	
