//LIBRERIA: libreriajs_draven.js - data: 11/Ottobre/2005 - versione: 3	~ 02 maggio 2007


/*
INDICE FILE:
			1) Funzioni di uso generico per il controllo dei campi di un form	riga 146
			2) Gestori evento onFocus											riga 292
			3) Motore di Validazione di form basato su regole					riga 320
			4) Funzione di preview per i form che prevedono l'inserimento di una immagine con anteprima

*/

 //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.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";

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";


/**************************************************************************************************************************************
 *  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 (isNaN(numero) || (numero.indexOf(".")!=-1) ) return false;
	 numero = parseInt(numero);
	if((minimo) && numero<minimo ) return false;
	if((massimo) && numero>massimo ) return false;

	return true;
}



/**************************************************************************************************************************************
 * 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[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;
}
/*
 * 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];

	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;
	}
	// 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( (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;
	//}
}
/*
 * 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.AggiungiRegolaComposta = AggiungiRegolaComposta;
}
/*
 * 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)
{
	posizione = eval(this.RegoleSemplici.length);
	  this.RegoleSemplici[posizione] = RegolaSemplice;
}

/* 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)
{
	 posizione = eval(this.RegoleComposte.length);
	  this.RegoleComposte[posizione] = RegolaComposta;
}


/**************************************************************************************************************************************
 * FUNZIONE PER L'ANTEPRIMA DI IMMAGINI NEL PANNELLO O NEI FORM CHE PREVEDONO L'UPLOAD DI UNA FOTO CON ANTEPRIMA
 * IMMEDIATA
 *
 */


function AnteprimaInImg( IdTagImg, Sorgente, FlagSorgente, IdTagCheckboxNoFoto )
	{
	/* Questa funzione permette di caricare in un tag img una immagine che può essere presa da un input di tipo file oppure da una cartella del sito.
		I parametri sono:
		IdTagImg - stringa che contiene l'id del tag img in cui visualizzare l'immagine. ESEMPIO <img id="1"> allora IdTagImg = "1"

		Sorgente - stringa che può contenere l'id del tag input di tipo file da cui prendere l'url della immagine
						  oppure il path dell'immagine. ESEMPIO : 1) <input type="file" id="Ciao" > allora Srogente = "Ciao"
						  2) Sorgente = "http://www.justweb.it/immagine.jpg" oppure "./immagine.jpg"

		FlagSorgente - Stringa che indica il significato di sorgente
			se Sorgente è l'id del campo input di tipo file allora FlagSorgente = "input"
			se Sorgente è l'url dell'immagine allora FlagSorgente = "url"

		IdTagCheckBoxNoFoto ( opzionale ) - Stringa che contiene l'id del input di tipo checkbox che serve per annullare l'invio di una immagine.
			è strettamente legato ai moduli: il checkbox "no foto" può essere spuntato automaticamente al caricamento: quindi dopo avere scelto una immagine
			dal disco, l'anteprima è mostrata nel tag img e se il checkbox no foto è abilitato allora viene messo a false ( non scelto ).
			ESEMPIO: <input type="checkbox" id="nofoto1" > allora  IdTagCheckboxNoFoto = "nofoto1"

		La funzione non restituisce nulla.
	*/

		var campoCheckbox = 0;
		if( IdTagCheckboxNoFoto ) {
			campoCheckbox = document.getElementById( IdTagCheckboxNoFoto );
		}

		var campoImmagine = document.getElementById( IdTagImg );
		var Immagine = new Image();

		if( ( FlagSorgente == "url" ) && ( campoImmagine ) ) {
			Immagine.src = Sorgente;

			campoImmagine.src = Immagine.src;
			return;
		}

		if( ( FlagSorgente == "input" ) && ( campoImmagine ) ){
			var Input = document.getElementById( Sorgente );

			if( ( Input ) && ( Input.value != "" ) ) {
				Immagine.src = Input.value;

				if( ( campoCheckbox ) && ( campoCheckbox.checked ) )	{
					campoCheckbox.checked = false;
				}

			campoImmagine.src = Immagine.src;
			return;
			}
		}
	}