var HIDDEN = "hidden";
var SHOWN = "shown";
var tabId=new Array();
var kCode;
var comboTimer = null;


/*
 * Restituisce l'elemento in posizione 'index' all'interno di un vettore
 * 
 * @param array, vettore in cui recuperare l'elemento
 * @param index, posizione dell'elemento, assume valori compresi tra 0 e len-1.					 
 * @param len, lunghezza del vettore. NON E' LA LUNGHEZZA DEL VETTORE RECUPERATA COME <array.length>!!!!
 */
function get(array, index, len) {
	if (array[len] == null) {
		return array[index]; // Firefox
	}
	return array[index + 1]; // Others
}

/**
 * Se visibile rende l'elemento con l'id corrispondente invisibile e viceversa
 */
function changeVisibility(id) {
	var elem = document.getElementById(id);
	if(elem.style.display != "none") {
		hide(id);
		return HIDDEN;	
	} 
	show(id);
	return SHOWN;
}
/**
 * Nasconde (se esiste) l'elemento con l'id specificato
 */
function hide(id) {
	var elem = document.getElementById(id);
	 if (elem)
		elem.style.display = "none";
}

/**
 * Mostra (se esiste) l'elemento con l'id specificato
 */
function show(id) {
	var elem = document.getElementById(id);
	 if (elem)
		elem.style.display = "";
}

function chiudiMgt(){
	$('menuflowSubView:flowMenu:chiudiMgt').click();
	return false;
}

function chiudiAmm(){
	$('menuflowSubView:flowMenu:chiudiAmm').click();
	return false;
}

/**
 * DA TESTARE
 * Restituisce true se l'elemento è disabilitato oppure se è all'interno di un elemento disabilitato
 */
function isDisabledElem(elem) {
	if(!elem)
		return false;
	if(elem.disabled)
		return true;
	return isDisabledElem(elem.parentNode);
}

function isDisabled(elemId){
	var elem = document.getElementById(elemId);
	if(isDisabledElem(elem)) 
		return true;
	return false;	
}

/**
 * Restituisce true se l'elemento è visibile (non ha style="display: none") oppure se è contentuo in un elemento visibile
 */
function isVisibleElem(elem) {
	if(!elem)
		return true;
	if(elem.style && elem.style.display == "none")
		return false;
	return isVisibleElem(elem.parentNode);
}

function isVisible(elemId){
	var elem = document.getElementById(elemId);
	if(isVisibleElem(elem)) 
		return true;
	return false;
}

function emptyField(field) {
	return (!field ||  field=='-1');
}


function highlightGroup(joinVect){
	if (joinVect && joinVect.length ){
		for (i = 0 ; i< joinVect.length ; i++){	
			if ( !emptyField($(joinVect[i]).value) ) {
				highlightOffVect(joinVect ) 	
				break;
			}
		}
	}
}

 
function highlightOn( item ){	
	obj = $(item); 
	if (obj) {
		obj.className += " warningHighlight";	
		show(obj.id + 'Error');
	}
}

function highlightOff( item ){	
	obj = $(item); 
	if (obj)  {
		obj.className =  obj.className.replace(/warningHighlight/g,""); 	
		hide(obj.id + 'Error');
	}

}
 
function highlightOnVect( itemArray ){	
	if (itemArray && itemArray.length ){ 
		for(var index=0; index< itemArray.length; index++) {
			highlightOn( itemArray[index]  );
		} 	
	}
}

function highlightOffVect( itemArray ){		
	if (itemArray && itemArray.length ){ 
		for(var index=0; index< itemArray.length; index++) {
			highlightOff( itemArray[index] );
		} 	
	}
}



/**
 *	utilizzo: onclick(this), onchange(this) 
 *	modifica lo sfondo di un elemento e modifica la visibilita' dei messaggi di errore
 * 			selezione non nulla  ==> bianco, errore non visibile (Id errore = Id elem + 'Error')  
 *			selezione nulla      ==> warningColor 
 */
function errorHighlight(elem) {
	if (elem) {
		var elemName = (elem.name || elem.id);
		var errorName = elemName + 'Error';
		if(document.getElementById(errorName) )	{
			var warningStyleClass = "warningHighlight";
			// Recupero l'elemento che contiene i radio buttons (di solito tabella generata dal tag JSF)
			var tab = document.getElementById(elemName);
			var inputElem = tab || elem;
			
			// Se il campo non è vuoto ...
			if (!emptyField(elem.value)){
				// ... nasconde il messaggio di errore
				hide(errorName);
				inputElem.className = inputElem.className.replace(/warningHighlight/g,"");
			} else {
				// Cerco eventuali figli (radio button all'interno della tabella)
				var children = document.getElementsByName(elemName);
				if (children) {
					for(var index=0; index<children.length; index++) {
						if (children[index].checked) {
							// Nasconde il messaggio di errore
							hide(errorName);
							inputElem.className = inputElem.className.replace(/warningHighlight/g,"");
							break;
						}
					}
				} else {
					// ... altrimenti aggiunge lo stile per l'errore
					if(inputElem.className){
						if(!inputElem.className.match(warningStyleClass))
							inputElem.className += " " + warningStyleClass;
					}
				}
				
			}
		}
	}
}

/**
 *	utilizzo: chiamato a fondo pagina 
 * 	cerca gli elementi che hanno ottenuto in messaggio d'errore nella validazione 
 * 	e ne cambia la styleclass in  "warningHighlight"  
 *	(Id errore = Id elem + 'Error')  
 */
function errorsValidationHighlight(){
	var formsNumber=document.forms.length;
	var pos=0;
	var errorNum=0;
	// Ciclo su ogni form
	for (var i=0;i<formsNumber;i++){
		// Ciclo su ogni elemento della form
		for (var j=0;j<document.forms[i].length;j++){
			// Se è un elemento di input
			if( document.forms[i].elements[j].type == "radio" 
						|| document.forms[i].elements[j].type == "text"
								|| document.forms[i].elements[j].type=="select-one"
										|| document.forms[i].elements[j].tagName=="INPUT"){
				errorCheck(document.forms[i].elements[j].name);
				
				/**
				 * Inizializzazione del vettore dei tabindex
				 */
				
				// Se un elemnto ha un attributo tabIndex...
				if (document.forms[i].elements[j].tabIndex){
					//... lo inserisco nel vettore 
					tabId[pos] = document.forms[i].elements[j];
					pos++;
				}
			}
		}
	}
	// Ordino il vettore in base ai tabindex
	quick_sort(tabId);

	//Ciclo sugli elementi e setto il focus sul primo con un errore	
	var errorFound = false;
	for (var j=0;j<tabId.length;j++){
		errorFound = errorCheck(tabId[j].name);
		if (errorFound) {
			setFocus(tabId[j]);
			break;
		}			
	}
	
	// se non ho trovato errori setto il focus sul primo
	if (!errorFound){
		for (var j=0;j<tabId.length;j++){		
			if (setFocus(tabId[j])) {
				break;
			}			
		}
	}
}

function setFocus(elem){
	if (isVisibleElem(elem) && !isDisabledElem(elem)){
		elem.focus();
		return true;
	}
	return false;
}


/**
 * 	se l'elemento ha ottenuto un messaggio d'errore nella validazione 
 * 	ne cambia la styleclass in  "warningHighlight"
 *	(Id errore = Id elem + 'Error')  
 */
function errorCheck(elemId){

	if ( elemId ) {
		var elem = document.getElementById(elemId);

		if ( elem && document.getElementById(elemId + 'Error')!= null ){
			if	(isVisible(elemId +'Error' ) && !elem.className.match("warningHighlight"))
				document.getElementById(elemId).className += " warningHighlight";
			return true;
		}
	}
	return false;
}



function partition(array, begin, end, pivot)
{
	var piv=array[pivot].tabIndex;
	array.swap(pivot, end-1);
	var store=begin;
	var ix;
	for(ix=begin; ix<end-1; ++ix) {
		if(array[ix].tabIndex<=piv) {
			array.swap(store, ix);
			++store;
		}
	}
	array.swap(end-1, store);

	return store;
}

Array.prototype.swap=function(a, b)
{
	var tmp=this[a];
	this[a]=this[b];
	this[b]=tmp;
}

function qsort(array, begin, end)
{
	if(end-1>begin) {
		var pivot=begin+Math.floor(Math.random()*(end-begin));
		pivot=partition(array, begin, end, pivot);
		qsort(array, begin, pivot);
		qsort(array, pivot+1, end);
	}
}
function quick_sort(array)
{
	qsort(array, 0, array.length);
}

function nextTab(elem){	
	var j;
	for (j=0;j<tabId.length;j++){
		if((tabId[j].tabIndex > elem.tabIndex) && isVisible(tabId[j].name) && !isDisabledElem(tabId[j]))			
			break;
	}
	if (j<tabId.length) {
		// tabId[j].focus();
		setFocus(tabId[j]);
	} else {
		// tabId[0].focus();
		setFocus(tabId[0]);
	}
}

function prevTab(elem){	

	var pos;
	var j;
	for (j=tabId.length-1;j>=0;j--){
		if(  (tabId[j].tabIndex < elem.tabIndex) && isVisible(tabId[j].name) && !isDisabledElem(tabId[j]))			
			break;
	}
	if (j>=0) {	
		// tabId[j].focus();
		setFocus(tabId[j]);
	} else {
		// tabId[(tabId.length-1)].focus();
		setFocus(tabId[(tabId.length-1)]);
	}
}


function toUppercase(string) {
	if (string && string.toUpperCase()) 
		return string.toUpperCase();
	return string;
}

/**
 * Cattura e gestisce la pressione di acuni tasti la pressione di alcuni tasti:
 * 
 * F5, Ctrl + R: Per impedire il refresh della pagina.
 * Ctrl + N: Per impedire che si apra una nuova finestra e quindi ricompaia la toolbar
 * Backspace: Per evitare il back del browser
 * TAB, Shift + TAB: Scorre ciclicamente gli elementi nei quali è stato impostato il tabindex ed ignora gli altri. 
 * 					Corregge il comportamento anomalo sotto firefox (il tab si ferma sulle selectList).
 * 					Vedi funzioni prevTab, nextTab

 */
function captureKey(ev) {
    var event = ev || window.event;             // IE: window.event  Others: ev
    var keyCode = event.keyCode || event.which;   // IE: keyCde FF: which
    var disableKey = false;

	kCode = keyCode;
    switch (keyCode) {
    	case 8: // Backspace    		
    		var test_var;
   			var test_type;
    		if (event.srcElement) {
    			test_var = event.srcElement.tagName;
    			test_type = event.srcElement.type;
    		} else {
    			test_var = event.target.nodeName;
    			test_type = event.target.type;
			}
   			test_var = toUppercase(test_var);
   			test_type = toUppercase(test_type);
			// Disabilito solo se NON è un campo di input Testo
			disableKey = (test_var != 'INPUT' && test_var != 'TEXTAREA') || (test_var == 'INPUT' && test_type == 'RADIO');
    		break;    		
    	case 9: // Tab
    		if (tabId && (tabId.length > 0)) {
    			var targ = event.target || event.srcElement;
				if (ev.shiftKey)
					prevTab(targ);
				else
					nextTab(targ);
				disableKey = true;		
    		}
    		break;      		
    	case 78: // N
    		disableKey = event.ctrlKey;
    		break;    		
    	case 82: // R
    		disableKey = event.ctrlKey;
    		break;
    	case 116: //F5
    		disableKey = true;
    		break;
    	default:
    		break;
    }
	
	if (disableKey) {
		// Annullo la pressione del tasto
		
		// window.status = "F5 key detected! Attempting to disabling default response.";
		// window.setTimeout("window.status='';", 2000);
	
		// Standard DOM (Mozilla):
		if (event.preventDefault) {
			event.preventDefault();
		}
	
		//IE 
		var isIE = document.all && window.event && !event.preventDefault;
		if (isIE) {
			event.cancelBubble = true;
			event.returnValue = false;
			event.keyCode = 0;
		}
		
		return false;
	}
}
/*
if (typeof window.event != 'undefined') {
	document.onkeydown = function() {
		var test_var=event.srcElement.tagName.toUpperCase();
		var test_type=(event.srcElement.type == undefined ? undefined : event.srcElement.type.toUpperCase());
		if (event.keyCode == 8) {
			if ((test_var != 'INPUT' && test_var != 'TEXTAREA') || (test_var == 'INPUT' && test_type == 'RADIO'))
				return false;
		} else
			return captureKey;
	}
	
} else {
	document.onkeypress = function(e) {
		var test_var=e.target.nodeName.toUpperCase();
		var test_type=(e.target.type == undefined ? undefined : e.target.type.toUpperCase());
		if ((test_var != 'INPUT' && test_var != 'TEXTAREA') || (test_var == 'INPUT' && test_type == 'RADIO'))
			return (e.keyCode != 8);
	}
	
	document.onkeydown = captureKey;
}*/

/**
 * Effettua delle azioni in base al tasto premuto. 
 * 
 * Richiama la funzione disableKeys, dsabilitando tutti i tasti specificati.
 * 
 * TAB, Shift + TAB: Scorre ciclicamente gli elementi nei quali è stato impostato il tabindex ed ignora gli altri. 
 * 					 Corregge il comportamento anomalo sotto firefox (il tab si ferma sulle selectList).
 * 					Vedi funzioni prevTab, nextTab
 * 
 *
function captureKey(ev) {
    var ev = ev || window.event;          // gets the event in ie or ns
    var kCode = ev.keyCode || ev.which;   // gets the keycode in ie or ns
	var targ = ev.target || ev.srcElement;

	disableKeys(ev);
	
	if (tabId && (tabId.length > 0)) {
		if (kCode==9) {
			if (ev.shiftKey)
				prevTab(targ);
			else
				nextTab(targ);
			return false;
		}
	}
}
 */

function hideGroupLabelError( id) {
		hide(id);
		hide(id + 'Label');
		hide(id + 'Error');
}

function showGroupLabelError( id) {
		show(id);
		show(id + 'Label');
		show(id + 'Error');
}

/**
 * obj: Stringa che rappresenta la funzione da ritardare
 */
function setComboTimer(obj) {
	clearTimeout(comboTimer);
	comboTimer = setTimeout(obj,250);
}

function refreshElements(elem, prevElem) {
	// textarea
	taElem = elem.getElementsByTagName('textarea');
	for (i = 0; i < taElem.length; i++) {
		setElementValueById(prevElem, taElem[i].id, 'textarea', taElem[i]);
	}
	// input
	rbElem = elem.getElementsByTagName('input');
	for (i = 0; i < rbElem.length; i++) {
		setElementValueById(prevElem, rbElem[i].id, 'input', rbElem[i]);
	}
	// select
	sElem = elem.getElementsByTagName('select');
	for (i = 0; i < sElem.length; i++) {
		setElementValueById(prevElem, sElem[i].id, 'select', sElem[i]);
	}
}

function setElementValueById(prevElem, id, type, elval) {
	iElem = prevElem.getElementsByTagName(type);
	for (j = 0; j < iElem.length; j++) {
		if (iElem[j].type == 'radio' && iElem[j].id == id) {
			if (iElem[j].value == elval.value && elval.checked) {
				iElem[j].checked=true;
			}
		} else {
			if (iElem[j].id == id) {
				iElem[j].value = elval.value;
			}
		}
	}
}

function getElementById(elem, id, type) {
	iElem = elem.getElementsByTagName(type);
	for (j = 0; j < iElem.length; j++) {
		if (iElem[j].type == 'radio' && iElem[j].id == id) {
			return iElem[j];
		} else {
			if (iElem[j].id == id) {
				return iElem[j];
			}
		}
	}
}

/*
 * Aggiunge una funzione associandola ad un evento di un oggetto
 * 		obj: oggetto a cui associare la funzione
 * 		ev: evento a cui associare la funzione.
 * 			l'evento coincide con quelli della W3C, deve essere specificato senza l'"on" es: keypress e NON onkeypress
 * 		fn: funzione da associare
 *
 * 	return true se la funzione è stata aggiunta, false nel caso contrario.
 * 
 * Es: addEvent(document, 'keypress', function);
 */
function addEvent(obj, evType, fn){ 
	if (obj.addEventListener) { //Opera, Safari, FF
		obj.addEventListener(evType, fn, false); 
		return true; 
	} else if (obj.attachEvent) {  // IE
		var r = obj.attachEvent("on" + evType, fn); 
		return r; 
	} else {  			
		return false; 
	} 
}

String.prototype.trim = function () {
    return this.replace(/^\s*/, "").replace(/\s*$/, "");
}

function getElementsBySelector(selector){
	var i;
	var s=[];
	var selid="";
	var selclass="";
	var tag=selector;
	var objlist=[];
	if(selector.indexOf(" ")>0){  //descendant selector like "tag#id tag"
	    s=selector.split(" ");
	    var fs=s[0].split("#");
	    if(fs.length==1) return(objlist);
	    return(document.getElementById(fs[1]).getElementsByTagName(s[1]));
	    }
	if(selector.indexOf("#")>0){ //id selector like "tag#id"
	    s=selector.split("#");
	    tag=s[0];
	    selid=s[1];
	    }
	if(selid!=""){
	    objlist.push(document.getElementById(selid));
	    return(objlist);
	    }
	if(selector.indexOf(".")>0){  //class selector like "tag.class"
	    s=selector.split(".");
	    tag=s[0];
	    selclass=s[1];
	    }
	var v=document.getElementsByTagName(tag);  // tag selector like "tag"
	if(selclass=="")
	    return(v);
	for(i=0;i<v.length;i++){
	    if(v[i].className.match(selclass)){
	        objlist.push(v[i]);
	        }
	    }
	return(objlist);
}

/**
 * 	realId( shortId )
 * 		
 * 		Verifica se esiste un elemento che abbia id = shortId, se esiste restituisce shortId altrimenti
 * 		scorre gli id delle form in pagina e controlla se esiste un elemento con id = formId + shortId
 *		se l'elemento viene trovato ritorna  		'formId + shortId'
 *		se l'elemento non viene trovato ritorna    	false
 * 
 */
  
function realId(shortId){
	if ($(shortId))
		return shortId;
		
	var formsArray = document.forms;
	var formsNumber = formsArray.length;
	var longId = null;
	for (i = 0 ; i< formsNumber ; i++) {
		longId = formsArray[i].id + ':'+ shortId;
		if ($(longId))
			return longId;
	}
	return false;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//// CALLING METHODS
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

// Aggiunge la funzione  per catturare la pressione di un tasto.
if (window.opera) {
	// Opera
	addEvent(document, 'keypress', captureKey); // Opera
} else {
	// Non Opera
	addEvent(document, 'keydown', captureKey); // Non Opera
}

/*
if (typeof window.event != 'undefined') {
	document.onkeydown = function() {
		var test_var=event.srcElement.tagName.toUpperCase();
		var test_type=(event.srcElement.type == undefined ? undefined : event.srcElement.type.toUpperCase());
		if (event.keyCode == 8) {
			if ((test_var != 'INPUT' && test_var != 'TEXTAREA') || (test_var == 'INPUT' && test_type == 'RADIO'))
				return false;
		} else
			return captureKey;
	}
	
} else {
	document.onkeypress = function(e) {
		var test_var=e.target.nodeName.toUpperCase();
		var test_type=(e.target.type == undefined ? undefined : e.target.type.toUpperCase());
		if ((test_var != 'INPUT' && test_var != 'TEXTAREA') || (test_var == 'INPUT' && test_type == 'RADIO'))
			return (e.keyCode != 8);
	}
	
	document.onkeydown = captureKey;
}
*/


/*
 * PARTE DI CODICE PER LA GESTIONE DELLO SCROLLING TRAMITE LA ROTELLINA DEL MOUSE.
 * Sotto Explorer lo scrolling selvaggia causa uno strana sovrapposizione dei campi di input sul monitor.
 * Questo fenomeno sembra avvenire su alcuni computer quando la proprieta di IE 
 * Strumenti->Opzioni Internet->Avanzate->"Usa scorrimento continuo" (Smooth scrolling)
 * è impostata.
 * 
 * Al momento è stato commentato perchè impedisce lo scorrimento delle voci all'interno del menù a tendina.
 */
 /*
if (window.addEventListener)  // MOZILLA
	window.addEventListener('DOMMouseScroll', wheel, false);

// IE / OPERA
window.onmousewheel = document.onmousewheel = wheel;

function wheel(event){
// Variabile che conterrà la variazione di movimento
	var delta = 0;

// INTERNET EXPLORER
	if (!event)
		event = window.event;

// INTERNET EXPLORER E OPERA
	if (event.wheelDelta) {
		delta = event.wheelDelta/120;
// IN OPERA 9 IL SEGNO E' INVERTITO
	if (window.opera)
		delta = -delta;
	}

// MOZILLA - LUNGA VITA A MOZILLA
	else if (event.detail){
// DELTA INVERTITO E MULTIPLO DI 3
delta = -event.detail / 3;
	}

// SE IL DELTA E' DIVERSO DA ZERO ESEGUE LA FUNZIONE HANDLE
	if (delta)
		handle(delta);

// BLOCCA SCROLLING IN PAGINE LUNGHE...
	if (event.preventDefault)
		event.preventDefault();

// RITORNA FALSO
	event.returnValue = false;
}

function handle(delta){
	window.scrollBy(0 , - 30 *delta );	
	
}
*/

startList= function(){}

/////// TAG SCRIPTS //////////
//params: nome del cookie, valore del parametro che viene passato al cookie, durata del cookie (giorni)
function writeCookie (cookieName, valuePlayer, days) {

	var today = new Date();
	today.setTime( today.getTime() );
	
	if ( days ) {
		days = days * 1000 * 60 * 60 * 24;
	}
	var expires_date = new Date( today.getTime() + (days) );
	
	document.cookie = cookieName + "=" + escape(valuePlayer) + "; path=/" + ( ( days ) ? ";expires=" + expires_date.toGMTString() : "" );
}

function getCookie(name){
		var dc = document.cookie;
		var prefix = name + "=";
		var begin = dc.indexOf("; " + prefix);
		if (begin == -1)
		{
			begin = dc.indexOf(prefix);
			if (begin != 0) return null;
		}
		else{
			begin += 2;
		}
	var end = document.cookie.indexOf(";", begin);
	if (end == -1)
	{ end = dc.length; }
	return unescape(dc.substring(begin + prefix.length, end));
}

/*
 *  Metodi per gestire il datepicker su tre campi DD/MM/YYYY
 */
function popola_data(){
	if(jQuery(".datepicker")[0].value!="")
		jQuery(".datepickerD")[0].value=jQuery(".datepicker")[0].value.split(/\//)[0];
	if(jQuery(".datepicker")[0].value!="")
		jQuery(".datepickerM")[0].value=jQuery(".datepicker")[0].value.split(/\//)[1];
	if(jQuery(".datepicker")[0].value!="")
		jQuery(".datepickerY")[0].value=jQuery(".datepicker")[0].value.split(/\//)[2];
}

function popola_data_hidden(){
	if(check_data(".datepickerY"))
		jQuery(".datepicker")[0].value=jQuery(".datepickerD")[0].value+"/"+jQuery(".datepickerM")[0].value+"/"+jQuery(".datepickerY")[0].value;
	else 
		jQuery(".datepicker")[0].value="";
}

/**
 * Esegue il click di un link anche su browser che non consentono la funzione "click()" di un elemento
 * (es. FireFox 3.x, Chrome, Safari, ...); e' l'equivalente di "link.click();"
 * @param link: elemento da cliccare
 * @return
 */
function clickLink(link) {
    var cancelled = false;

    if (document.createEvent) {
        var event = document.createEvent("MouseEvents");
        event.initMouseEvent("click", true, true, window,
            0, 0, 0, 0, 0,
            false, false, false, false,
            0, null);
        cancelled = !link.dispatchEvent(event);
    }
    else if (link.fireEvent) {
        cancelled = !link.fireEvent("onclick");
    }

    if (!cancelled) {
        window.location = link.href;
    }
}