/* -----------------------------------------------------------------------------------
------- location.Key[IdChiave][1] e location.QS("NomeChiave") ------------------------
------- Restituiscono i parametri ricevuti dalla pagina nella QueryString
------- 
------- ValoreParametro = location.key[NumPar][1];
-------       NumPar e' l'ordinale della coppia nella stringa a partire da 0 (zero)
------- 
------- ValoreParametro = location.QS("NomeParametro");
-------       NomeParametro e' il nome del parametro ricevuto nella stringa
-------                                                                            --- */
var Keys = unescape(location.search.substr(1)).split("&");
for (var _Id in Keys)
	Keys[_Id]=Keys[_Id].split("=");
location.Key = Keys;

function QueryString(_key){
	var _QSvalue;
	for (var _Id in location.Key)
		if (location.Key[_Id][0]==_key)
			return location.Key[_Id][1];
	}
location.QS=QueryString;
/* ----------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------
------- Trim(), LTrim(), RTrim() -----------------------------------------------------
------- 
------- Metodi per l'oggetto String, restituiscono la stringa cui sono applicati
------- senza spazi iniziali e/o finali:
------- 
------- str_a = stringa.Trim();
-------       str_a contiene il valore di stringa senza spazi iniziali ne' finali
------- 
------- str_a = stringa.LTrim();
-------       str_a contiene il valore di stringa senza spazi iniziali
------- 
------- str_a = stringa.RTrim();
-------       str_a contiene il valore di stringa senza spazi finali
------- 
------- N.B.
------- [\s] nelle RegExp contiene sia gli spazi che i ritorni a capo, avanzamento riga
------- tabulatore, tabulatore verticale. Tutti questi caratteri, se presenti, verranno
------- eliminati.
-------                                                                            --- */
function Trim() {
   return this.replace(/\s+$|^\s+/g,"");
   }

function LTrim() {
   return this.replace(/^\s+/,"");
   }

function RTrim() {
   return this.replace(/\s+$/,"");
   }
	
String.prototype.Trim=Trim;	
String.prototype.RTrim=RTrim;	
String.prototype.LTrim=LTrim;	
/* ----------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------
------- SpecialChars( [TipoSostituzione] ) -------------------------------------------
------- Metodo aggiuntivo per l'oggetto String, consente di sostituire,nella stringa
------- cui viene applicato, le lettere accentate con i corrispondenti codici HTML e
------- viceversa.
------- 
------- Supponendo di avere: Str1=" però ", Str2= " partì "
------- 
------- Str1.SpecialChars(); restituisce " però "
------- 
------- Str1.SpecialChars(true); restituisce " però "
------- 
------- Str2.SpecialChars(false); restituisce " partì "
------- 
-------                                                                            --- */
function SpecialChars(_flag)
	{
	_flag=arguments.length?_flag?0:1:0;
	var _CharsArray= [
		["à","à"],
		["è","è"],
		["é","é"],
		["ì","ì"],
		["ò","ò"],
		["ù","ù"]
		];
	var _SpecialChars=this.toString();
		for (i in _CharsArray)
			_SpecialChars=_SpecialChars.replace(new RegExp(_CharsArray[i][_flag],"g"),_CharsArray[i][1-_flag]);
	return _SpecialChars;
	}

String.prototype.SpecialChars=SpecialChars;
/* ----------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------
------- Swap(Id1,Id2) ----------------------------------------------------------------
------- Metodo per l'oggetto Array, consente, in soli array monodimensionali, di scam-
------- biare il valore degli elementi di indice Id1 e Id2 passati al metodo.
------- 
------- Dato l'array: var Nums = New Array("1","2","3","4","5","6");
------- Nums.Swap(1,4) restituisce l'array ("1","5","3","4","2","6");
------- 
------- N.B.
------- Il metodo non controlla l'esistenza degli indici ricevuti, quindi puo' essere
------- usato cosi' com'e' solo su array che non contengono "buchi" cioe' indici senza
------- elementi associati.
------- 
-------                                                                            --- */
function Swap(_sca,_scb)
	{
	_temp=this[_swa];
	this[_swa]=this[_swb];
	this[_swb]=_temp;
	return this;
	}

Array.prototype.Swap=Swap;
/* ----------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------
------- Randomize() ------------------------------------------------------------------
------- Metodo per l'oggetto Array che consente di mescolarne gli elementi.
------- Va usato insieme al metodo Swap().
------- 
------- MioArray.Randomize()
-------       Restituisce l'array di partenza con i valori mescolati.
------- 
------- 
------- NOTA BENE ! ! !
------- Non ha senso un'istruzione del genere:
------- 
-------       NuovoArray = VecchioArray.Randomize();
------- 
------- perche' il metodo opera comunque su VecchioArray (che dunque viene effettiva-
------- mente mescolato) e l'assegnazione a NuovoArray non duplica il Vecchio nel Nuovo,
------- bensi' crea un PUNTATORE agli elementi del vecchio array.
------- Modificando un elemento di NuovoArray o di VecchioArray la modifica verrebbe
------- comunque effettuata su VecchioArray e NuovoArray ne rifletterebbe semplicemente
------- i nuovi valori
------- 
------- Per duplicare un array in un altro, vedere le faq su http://www.jsdir.com/faq
------- alla categoria "Oggetti"
-------                                                                            --- */
function Randomize()
	{
	_RandCicli=100+parseInt(10000*Math.random());
	var _RandArrlen=this.length;
	while (_RandCicli-- > 0)
		this.Swap(0,parseInt(_RandArrlen*Math.random()));
	return this;
	}

Array.prototype.Randomize=Randomize;
/* ----------------------------------------------------------------------------------- */

/* -----------------------------------------------------------------------------------
------- LayerWrite() -----------------------------------------------------------------
------- Non e' un metodo, ma semplicemente una funzione che consente di scri-
------- vere in un livello il testo desiderato senza preoccuparsi delle varie sin-
------- tassi dato che e' crossbrowser
-------
------- Sintassi:
-------
------- LayerWrite("nomelayer", "testodascrivere" )
------- LayerWrite("nomelayer",textvar)
------- 
------- dove:
-------    nomelayer (stringa) e' il nome del livello in cui scrivere
------- e
-------   "testodascrivere" o -textvar- sono rispettivamente una stringa da
-------   scrivere nel layer oppure una variabile che contiene la stringa
------- 
------- Perche' sia certo il funzionamento il livello dev'essere inserito nel 
------- documento con sintassi tipo:
------- 
------- <div id="nomelivello" stye=" ... position:absolute; ...">
------- 
------- "position:absolute", in particolare, e' importante perche' la funzione
------- riesca a scrivere nel caso il browser sia Netscape4
------- 
-------                                                                            --- */
function LayerWrite(_layer, _testo)
   {
   if (document.layers)
      with (document.layers[_layer].document) {
         open();
         write(_testo);
         close();
		 }
   else if (document.getElementById)
      document.getElementById(_layer).innerHTML=_testo;
      else _layer.innerHTML=_testo
   }

function ReplaceString(oldS,newS,fullS) {
    for (var i=0; i<fullS.length; i++) {
        if (fullS.substring(i,i+oldS.length) == oldS){
             fullS = fullS.substring(0,i)+newS+fullS.substring(i+oldS.length,fullS.length);
         }	
		}
         return fullS
}  


/*--
============= Funzione per li controllo delle email ==============
controlla se una email e' buona e restituisce true o false
--*/

function controllaMail(em) {
  
   EmailAddr = em;
   Filtro = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-]{2,})+\.)+([a-zA-Z0-9]{2,})+$/;
   if (Filtro.test(EmailAddr))
      return true;
   else {
      return false;
      }
   }



// altre funzioni -----------------------------------------------
function cancTesto(){
	if(document.frmCerca.parola.value=="Cerca nel sito"){
	document.frmCerca.parola.value="";	
	}
}

function ripristinaTesto(){
	if(document.frmCerca.parola.value=="" || document.frmCerca.parola.value==" "){
	document.frmCerca.parola.value="Cerca nel sito";
	}  
}  
function apriZoom(pg, nome, w, h) {
	opt='width=' + w + ',height=' + h + ',menubar=no,resizable=yes,scrollbars=yes, status=no'
	window.open (pg, nome, opt)
}


function chiedi(indirizzo){
var esito;

esito=confirm("Volete davvero eliminare il seguente record ?");
	if(esito){
	document.location.href=indirizzo;
	}
}

function chiediCosa(indirizzo,cosa){
var esito;

esito=confirm("Volete davvero eliminare "+  cosa +" ?");
	if(esito){
	document.location.href=indirizzo;
	}
}


function chiediCosaImg(indirizzo,cosa){
var esito;

esito=confirm("Volete davvero eliminare "+  cosa +" ? \nAttenzione! Eliminando la miniatura verra' automaticamente eliminato anche lo zoom corrispondente."  );
	if(esito){
	document.location.href=indirizzo;
	}
}


function chiediCosaOff(indirizzo,cosa){
var esito;

esito=confirm("Volete davvero eliminare "+  cosa +" ? \nAttenzione! \nInsieme all'offerta verranno automaticamente eliminate anche le immagini."  );
	if(esito){
	document.location.href=indirizzo;
	}
}


function apri(pg, nome, w, h) {
	opt='width=' + w + ',height=' + h + ',menubar=yes,resizable=yes,scrollbars=yes, status=yes'
	window.open (pg, nome, opt)
}

function aprifinestra(pag,larg,altez){
window.open(pag,'Details','scrollbars=yes,resizable=yes,width='+ larg +',height='+altez);
}


function isDate(gg,mm,aaaa) {
	mm = mm-1;
	var d = new Date(aaaa,mm,gg);
	return (d.getDate()==gg && d.getMonth()==mm && d.getFullYear()==aaaa);
}

/*
========Controlla due date se la seconda è posteriore alla prima ===========0
Accetta 3  parametri per la data di partenza
3 parametri per la data di fine e 
parita= true/false per sapere se deve accettare la parita' (true) tra le due date 
nelPassato=true: se le date possono rappresentare un intervallo di tempo nel passato; false: obblica a usarlo solo nel presente o futuro;
esempio:
esito=contrIntervalloDate(giornoDA, meseDa, annoDa, giornoA, meseA, annoA, true, false);
[stiamo controllando l'arco di tempo tra le due date e stiamo chiedendo che possano essere contemporanee ma non  possono esprimere un intervallo di tempo nel passato]
*/


function controllaIntervalloDate(g_DA, m_DA, a_DA, g_a, m_a, a_a, parita, nelPassato){
	// -------- controlliamo se i primi 6 argomenti sono arrivati
	if(g_DA.length==0 ||  m_DA.length==0 || a_DA.length==0 || g_a.length==0,  m_a.length==0, a_a.length==0 ){
	return false;
	}
	// -------- controlliamo se i primi 6 argomenti sono arrivati
	
		if(isDate(g_DA, m_DA, a_DA) && isDate(g_a, m_a, a_a)){ // se le date sono corrette
			var oggi=new Date();
			var g_oggi=oggi.getDate();
			var m_oggi=oggi.getMonth()+1;
			var a_oggi=oggi.getFullYear();
			
			var zerog="";
			var zerom="";
			
			if(g_oggi<10){
			zerog="0";
			}
			
			if(m_oggi<10){
			zerom="0";
			}

		
			 oggiy=a_oggi.toString() +  zerom + m_oggi.toString() + zerog +g_oggi.toString();	
			 
			ind_da=dataDa_a.toString() + dataDa_m.toString() + dataDa_g.toString();
			ind_a=dataA_a.toString() + dataA_m.toString() + dataA_g.toString();
				
			var oggix=parseInt(oggiy);				
			var ind_dax=parseInt(ind_da);
			var ind_ax=parseInt(ind_a);
		
		// ------- vediamo subito se supera il test del passato ---------
			if(nelPassato==false){ // se non si possono scegliere periodi nel passato
					if(ind_ax<oggix){ // la scadenza è nel passato
						return false;	
					}
			}

		// ------- /vediamo subito se supera il test del passato ---------
			
		// -------- ora vediamo se le date sono coerenti  --------------
			if(ind_ax<ind_dax){ // se la data a è anteriore a da 
					return false;
			}
			else if(ind_ax==ind_dax){ // caso di parita
						if(parita){ // se la parita' è ammessa
							return true;	
						}
						else{ // parita non ammessa
							return false;
						}
			}// caso di parita						
			else if(ind_ax>ind_dax){ // caso data scadenza posteriore alla data inizio : OK
					return true;
			}// caso data scadenza posteriore alla data inizio : OK
		// -------- ora vediamo se le date sono coerenti  --------------

		
	
	}// se le date sono corrette
	else{ // le date non sono corrette
		return false;		
	}// le date non sono corrette

}
  //----------------------------------------------------------------------