/**
 * Piccola libreria per accedere ad elementi dom, stili. Gestione eventi, etc. compatibile cross browser.
 * @name		toolbox_clear.js
 * @encoding	UTF-8
 * @project		Socialnet - Libero
 * @package		common
 * @author		Giulio D'Ambrosio <giulio.dambrosio@staff.libero.it>, <giulio.dambrosio@poste.it>
 * @creation	27/ago/08
 * @version		Cvs: $Id: toolbox.js,v 1.5 2009/10/07 09:34:24 giulio_dambrosio Exp $
 *
 */
if (typeof(Array.prototype.indexOf) == "undefined") {
	/**
	 * Restituisce l'indice di un elemento se presente
	 * oppure restituisce -1
	 *
	 * @param {Array} item		Elemento da ricercare nell'array
	 * @return {int}	Indice dell'elemento se viene trovato, -1 altrimenti
	 *
	 * @example	var index = ['mela', 'pera', 'arancia'].indexOf('pera'); // index sarà uguale ad 1
	 */
	Array.prototype.indexOf = function(item){
		for (var i = 0; i < this.length; i++) {
			if (this[i] === item) {
				return i;
			}
		}
		return -1;
	}
}
if (typeof(Function.prototype.bind) == 'undefined') {
  function bind(context) {
    if (arguments.length < 2 && typeof(arguments[0])=='undefined') return this;
    var __method = this, args = slice.call(arguments, 1);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(context, a);
    }
  }

}
if (typeof(String.prototype.trim) == 'undefined') {
	/**
	 * Elimina whitespace se presente alle estremità di una stringa
	 * @return	{String}	La stringa "trimmata"
	 * @example	var trimmedString="  ciao  ".trim();	// trimmedString sarà "ciao" dopo la chiamata
	 */
	String.prototype.trim = function(){
		a = this.replace(/^\s+/, '');
		return a.replace(/\s+$/, '');
	};
}

if (typeof(Array.prototype.shift) == 'undefined') {
	/**
	 * Rimuove il primo elemento dell'array e lo restituisce
	 * @return {Object}		Il primo elemento dell'array
	 * @example	var shiftedElem=['primo','secondo','terzo'].shift();	// shiftedElem sarà uguale a 'primo', mentre l'array sarà ['secondo', 'terzo']
	 */
	Array.prototype.shift = function(){
		var elem = this.length > 0 ? this[0] : null;
		for (var i = 1; i < this.length; i++) {
			this[i - 1] = this[i] /* shift element downwards */
		}
		this.length = this.length - 1;
		return elem;
	};
}
if (typeof(Array.prototype.unshift) == 'undefined') {
	/**
	 * Inserisce un elemento nell'array, all'indice 0.
	 * @note La funzione è analoga all'omonima del php
	 * @param {Object} item			L'elemento da inserire
	 * @example	var arr=['secondo','terzo'].unshift('primo');	// arr sarà uguale a ['primo','secondo','terzo']
	 */
	Array.prototype.unshift = function(item){
		this[this.length] = null;/* create a new last element */
		for (var i = 1; i < this.length; i++) {
			this[i] = this[i - 1]; /* shift elements upwards */
		}
		this[0] = item;
	};
}
if (typeof(Array.prototype.sort) == 'undefined') {
	/**
	 * Ordina l'array in verso ascendente
	 */
	Array.prototype.sort = function(){
		var tmp;
		for (var i = 0; i < this.length; i++) {
			for (var j = 0; j < this.length; j++) {
				if (this[i] < this[j]) {
					tmp = this[i];
					this[i] = this[j];
					this[j] = tmp;
				}
			}
		}
	};
}

if (typeof(Array.prototype.contains) == 'undefined') {
	/**
	 * La funzione restituisce true se l'elemento passato come parametro è
	 * contenuto nell'array. False altrimenti
	 *
	 * @param {Object} element		Elemento da cercare
	 * @return {bool}	true se presente, false altrimenti
	 * @example	var found=['primo'].contains('secondo');	// found sarà uguale a false
	 */
	Array.prototype.contains = function(element){
		for (var i = 0; i < this.length; i++) {
			if (this[i] == element) {
				return true;
			}
		}
		return false;
	};
}

// get element & element style
if (typeof($) == 'undefined') {
	if (document.getElementById) {
		/**
		 * Funzione usata per accedere ad elementi presenti nel dom di un documento
		 *
		 * @note	La funzione è analoga a quella di prototype, ma ha alcune differenze: viene definita in base al browser, in modo da evitare il controllo del tipo di browser durante l'esecuzione. Inoltre accetta come parametro un elemento, restituendolo.
		 * @param {Object} element		Element può essere un array di elementi, oppure una stringa pari all'id dell'elemento ricercato, oppure un elemento dom.
		 * @return {mixed} Se il parametro era singolo, sarà restituito un singolo elemento se trovato, oppure null. Altrimenti sarà restituito un array contenente gli elementi ricercati
		 * @example var elem=$('id_elemento'); // elem conterrà l'elemento avente id=='id_elemento' oppure null
		 */
		$ = function(element){
			if (arguments.length > 1) {
				for (var i = 0, elements = [], length = arguments.length; i < length; i++) 
					elements.push($(arguments[i]));
				return elements;
			}
			return typeof(element) == "string" ? document.getElementById(element) : typeof(element) == "object" ? element : false;
		};
	}
	else {
		if (document.all) {
			/**
			 * Funzione usata per accedere ad elementi presenti nel dom di un documento
			 *
			 * @note	La funzione è analoga a quella di prototype, ma ha alcune differenze: viene definita in base al browser, in modo da evitare il controllo del tipo di browser durante l'esecuzione. Inoltre accetta come parametro un elemento, restituendolo.
			 * @param {Object} element		Element può essere un array di elementi, oppure una stringa pari all'id dell'elemento ricercato, oppure un elemento dom.
			 * @return {mixed} Se il parametro era singolo, sarà restituito un singolo elemento se trovato, oppure null. Altrimenti sarà restituito un array contenente gli elementi ricercati
			 * @example var elem=$('id_elemento'); // elem conterrà l'elemento avente id=='id_elemento' oppure null
			 */
			$ = function(element){
				if (arguments.length > 1) {
					for (var i = 0, elements = [], length = arguments.length; i < length; i++) 
						elements.push($(arguments[i]));
					return elements;
				}
				return typeof(element) == "string" ? document.all[element] : typeof(element) == "object" ? element : false;
			};
		}
		else {
			if (document.layers) {
				function getObjNN4(obj, name){
					var x = obj.layers;
					var foundLayer;
					for (var i = 0; i < x.length; i++) {
						if (x[i].id == name) 
							foundLayer = x[i];
						else {
							if (x[i].layers.length) 
								var tmp = getObjNN4(x[i], name);
						}
						if (tmp) 
							foundLayer = tmp;
					}
					return foundLayer;
				};
				/**
				 * Funzione usata per accedere ad elementi presenti nel dom di un documento
				 *
				 * @note	La funzione è analoga a quella di prototype, ma ha alcune differenze: viene definita in base al browser, in modo da evitare il controllo del tipo di browser durante l'esecuzione. Inoltre accetta come parametro un elemento, restituendolo.
				 * @param {Object} element		Element può essere un array di elementi, oppure una stringa pari all'id dell'elemento ricercato, oppure un elemento dom.
				 * @return {mixed} Se il parametro era singolo, sarà restituito un singolo elemento se trovato, oppure null. Altrimenti sarà restituito un array contenente gli elementi ricercati
				 * @example var elem=$('id_elemento'); // elem conterrà l'elemento avente id=='id_elemento' oppure null
				 */
				$ = function(element){
					if (arguments.length > 1) {
						for (var i = 0, elements = [], length = arguments.length; i < length; i++) 
							elements.push($(arguments[i]));
						return elements;
					}
					return typeof(element) == "string" ? findObjNN4(document, element) : typeof(element) == "object" ? element : false;
				};
			}
		}
	}
}
if (typeof($s) == 'undefined') {
	if (document.getElementById || document.all) {
		/**
		 * Funzione usata per accedere all'attributo "style" di un elemento, dato l'elemento stesso, oppure la stringa del suo id
		 *
		 * @param {Object} element		Element può essere un array di elementi, oppure una stringa pari all'id dell'elemento ricercato, oppure un elemento dom.
		 * @return {mixed} Se il parametro era singolo, sarà restituito un singolo oggetto di tipo style appartenente all'elemento se trovato, oppure null. Altrimenti sarà restituito un array contenente gli styles degli elementi ricercati
		 * @example	var elem=$s('id_elemento').display;	// Elem conterrà il valore dell'attributo display attualmente valido per l'elemento ricercato
		 */
		$s = function(element){
			return $(element).style;
		};
	}
	else {
		/**
		 * Funzione usata per accedere all'attributo "style" di un elemento, dato l'elemento stesso, oppure la stringa del suo id
		 *
		 * @param {Object} element		Element può essere un array di elementi, oppure una stringa pari all'id dell'elemento ricercato, oppure un elemento dom.
		 * @return {mixed} Se il parametro era singolo, sarà restituito un singolo oggetto di tipo style appartenente all'elemento se trovato, oppure null. Altrimenti sarà restituito un array contenente gli styles degli elementi ricercati
		 * @example	var elem=$s('id_elemento').display;	// Elem conterrà il valore dell'attributo display attualmente valido per l'elemento ricercato
		 */
		$s = function(element){
			return $(element);
		};
	}
}

if (typeof((Libero)) == "undefined") {
	/**
	 * Oggetto contenitore delle funzioni
	 */
	Libero = {
		Version: '1.0.0'
	};
}
/**
 * Alcuni defines provenienti da prototype
 */
if (typeof((Prototype)) == "undefined") {
	var Class = {
		create: function(){
			return function(){
				this.initialize.apply(this, arguments);
			}
		}
	};
	Object.extend = function(destination, source){
		if (typeof(source) == 'object') {
			for (var property in source) {
				destination[property] = source[property];
			}
		}
		return destination;
	};
}

// Create search class
Libero.Utils = Class.create();
Libero.Utils.prototype = {

	initialize: function(){
	}
	/**
	 * Inizializza le opzioni non definite, con valori di default, e restituisce
	 * un oggetto contenente l'unione dei due insieme, dando precedenza alle opzioni
	 * passate
	 * @param {Object} defaultvalues		Valori di default
	 * @param {Object} options				Valori esplicitamente definiti nella chiamata
	 */
	,
	standardizeOptions: function(defaultvalues, options){
		if (typeof(options) == 'object') {
			var result = {};
			for (var i in defaultvalues) {
				result[i] = (!options[i]) ? defaultvalues[i] : options[i];
			}
			return result;
		}
		else {
			return defaultvalues;
		}
	}	// Event Handling
	/**
	 * Collega una funzione ad un evento su un oggetto
	 *
	 * @param {Object} element			Elemento da "ascoltare"
	 * @param {String} eventName		Nome dell'evento da ascoltare
	 * @param {function} handler		Funzione da "attaccare" alla catena degli "ascoltatori" sull'evento dell'elemento
	 */
	,
	startListening: function(element, eventName, handler){
		if (typeof(element.addEventListener) != 'undefined') {
			// W3C
			element.addEventListener(eventName, handler, false);
		}
		else {
			if (typeof(element.attachEvent) != 'undefined') {
				// IE 6
				element.attachEvent("on" + eventName, handler);
			}
			else {
				// IE 5 Mac and some others
				element['on' + eventName] = handler;
			}
		}
	}
	/**
	 * Scollega una funzione da un evento su un oggetto
	 *
	 * @param {Object} element			Elemento da "ascoltare"
	 * @param {String} eventName		Nome dell'evento da ascoltare
	 * @param {function} handler		Funzione da "staccare" dalla catena degli "ascoltatori" sull'evento dell'elemento
	 */
	,
	stopListening: function(element, eventName, handler){
		if (typeof(element.removeEventListener) != 'undefined') {
			// W3C
			element.removeEventListener(eventName, handler, false);
		}
		else {
			if (typeof(element.detachEvent) != 'undefined') {
				// IE 6
				element.detachEvent("on" + eventName, handler);
			}
			else {
				// IE 5 Mac and some others
				element['on' + eventName] = null;
			}
		}
	}
	/**
	 * Interrompe la propagazione di un evento
	 * @param {Object} Evento da interrompere
	 */
	,
	stopEvent: function(event){
		if (event.preventDefault) {
			event.preventDefault();
			event.stopPropagation();
		}
		else {
			event.returnValue = false;
			event.cancelBubble = true;
		}
	},
	/**
	 * Genera un evento "custom"
	 * @param {Object|String}	element		Elemento associato all'evento
	 * @param {String}			eventName	Nome identificativo dell'evento
	 * @param {Object}			memo		Oggetto contenente i parametri custom dell'evento
	 * @param {Boolean}			bubble		Se true l'evento sarà di tipo bubble
	 */
	fireEvent: function(element, eventName, memo, bubble){
		var event;
		if (typeof(element) == 'string') {
			element = $(element);
		}
		if (element == document && document.createEvent && !element.dispatchEvent) {
			element = document.documentElement;
		}
		
		if (typeof(Object.bubble) == 'undefined') {
			bubble = true;
		}
		
		if (document.createEvent) {
			event = document.createEvent('HTMLEvents');
			event.initEvent('dataavailable', true, true);
		}
		else {
			event = document.createEventObject();
			event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
		}
		
		event.eventName = eventName;
		event.memo = memo ||
		{};
		
		if (document.createEvent) {
			element.dispatchEvent(event);
		}
		else {
			element.fireEvent(event.eventType, event);
		}
		
		return event;
	}
	/**
	 * Restituisce l'evento corrente
	 * @example
	 * @param {Object} evt		[optional] L'oggetto evento ricevuto dalla funzione richiamata dal sistema
	 */
	,
	getEvent: function(evt){
		return typeof(evt) != 'undefined' ? evt : typeof(window.event) != 'undefined' ? window.event : false;
	}
	/**
	 * Dato un evento, restituisce l'elemento a cui esso è associato
	 *
	 * @param {Object} evt		L'evento scatenato
	 */
	,
	getEventTarget: function(evt){
		var tgt = typeof(evt.originalTarget) != 'undefined' ? evt.originalTarget : typeof(evt.target) != 'undefined' ? evt.target : typeof(evt.srcElement) != 'undefined' ? evt.srcElement : false;
		if (tgt && (tgt.nodeType == 3 || tgt.nodeType == 4)) {
			tgt = tgt.parentNode;
		}
		return tgt;
	} // Element Dimensions
	/**
	 * Restituisce l'ascissa della posizione del mouse al momento di un evento
	 *
	 * @param {Object} evt		L'evento scatenato
	 * @return	int		ascissa della posizione del mouse
	 */
	,
	getMouseX: function(evt){
		return (evt.pageX) ? evt.pageX : (evt.clientX) ? evt.clientX + (document.documentElement.scrollLeft ? document.documentElement.scrollLeft : document.body.scrollLeft) : 0;
	}
	/**
	 * Restituisce l'ordinata della posizione del mouse al momento di un evento
	 *
	 * @param {Object} evt		L'evento scatenato
	 * @return	int		ordinata della posizione del mouse
	 */
	,
	getMouseY: function(evt){
		return (evt.pageY) ? evt.pageY : (evt.clientY) ? evt.clientY + (document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop) : 0;
	}
	/**
	 * Restituisce le coordinate dell'angolo superiore sinistro dell'elemento
	 * in coordinate assolute (0, 0) == angolo superiore sinistro di body
	 * @param {Object} element
	 * return {Array} array contenente due integer: [left: integer, top: integer]
	 * @example	var pos=toolbox.getElementPosition(element);	//
	 */
	,
	getElementPosition: function(element){
		var valueT = 0, valueL = 0;
		do {
			valueT += element.offsetTop || 0;
			valueL += element.offsetLeft || 0;
			element = element.offsetParent;
			if (element) {
				if (element.tagName == 'BODY') {
					break;
				}
				var p = $s(element).position;
				if (p == 'relative' || p == 'absolute') {
					break;
				}
			}
		}
		while (element);
		return {
			left: valueL,
			top: valueT
		};
	}	/*}
	/**
* Restituisce la larghezza di un elemento
	 *
	 * @param {Object} element	Elemento di cui si vuole conoscere la larghezza
	 * @return	int		larghezza dell'elemento
	 */
	,
	getWidth: function(element){
		if (typeof(element) != 'object') 
			element = $(element);
		var display = $s(element).display;
		if (display != 'none' && display != null) // Safari bug
			return element.offsetWidth;
		
		// All *Width and *Height properties give 0 on elements with display none,
		// so enable the element temporarily
		var els = $s(element);
		var originalVisibility = els.visibility;
		var originalPosition = els.position;
		var originalDisplay = els.display;
		els.visibility = 'hidden';
		els.position = 'absolute';
		els.display = 'block';
		var originalWidth = element.clientWidth;
		//var originalHeight = element.clientHeight;
		els.display = originalDisplay;
		els.position = originalPosition;
		els.visibility = originalVisibility;
		return originalWidth;
	}
	/**
	 * Restituisce l' altezza di un elemento
	 *
	 * @param {Object} element	Elemento di cui si vuole conoscere l' altezza
	 * @return	int		altezza dell'elemento
	 */
	,
	getHeight: function(element){
		if (typeof(element) != 'object') 
			element = $(element);
		var display = $s(element).display;
		if (display != 'none' && display != null) // Safari bug
			return element.offsetHeight;
		
		// All *Width and *Height properties give 0 on elements with display none,
		// so enable the element temporarily
		var els = $s(element);
		var originalVisibility = els.visibility;
		var originalPosition = els.position;
		var originalDisplay = els.display;
		els.visibility = 'hidden';
		els.position = 'absolute';
		els.display = 'block';
		//var originalWidth = element.clientWidth;
		var originalHeight = element.clientHeight;
		els.display = originalDisplay;
		els.position = originalPosition;
		els.visibility = originalVisibility;
		return originalHeight;
	}
	/**
	 * Restituisce larghezza e altezza di un elemento
	 *
	 * @param {Object} element	Elemento di cui si vuole conoscere larghezza e altezza
	 * @return	{Array}		[width:larghezza, height:altezza] (dell'elemento)
	 */
	,
	getDimensions: function(element){
		if (typeof(element) != 'object') 
			element = $(element);
		var display = $s(element).display;
		if (display != 'none' && display != null) // Safari bug
			return {
				width: element.offsetWidth,
				height: element.offsetHeight
			};
		
		// All *Width and *Height properties give 0 on elements with display none,
		// so enable the element temporarily
		var els = $s(element);
		var originalVisibility = els.visibility;
		var originalPosition = els.position;
		var originalDisplay = els.display;
		els.visibility = 'hidden';
		els.position = 'absolute';
		els.display = 'block';
		var originalWidth = element.clientWidth;
		var originalHeight = element.clientHeight;
		els.display = originalDisplay;
		els.position = originalPosition;
		els.visibility = originalVisibility;
		return {
			width: originalWidth,
			height: originalHeight
		};
	}
	/**
	 * Imposta l'opacità di un elemento
	 * @param {Object} element		Elemento Dom
	 * @param {Float} value			0 = trasparente, 1 = opaco
	 */
	,
	setOpacity: function(element, value){
		if (!!(window.attachEvent && !window.opera)) {
			function stripAlpha(filter){
				return filter.replace(/alpha\([^\)]*\)/gi, '');
			}
			var currentStyle = element.currentStyle;
			if ((currentStyle && !currentStyle.hasLayout) ||
			(!currentStyle && element.style.zoom == 'normal')) 
				element.style.zoom = 1;
			
			var style = element.style;
			var filter = typeof(style.filter) == 'undefined' ? '' : style.filter;
			if (value == 1 || value === '') {
				(filter = stripAlpha(filter)) ? style.filter = filter : style.filter = '';
				return;
			}
			else 
				if (value < 0.00001) 
					value = 0;
			style.filter = stripAlpha(filter) +
			'alpha(opacity=' +
			(value * 100) +
			')';
		}
		else {
			element.style.opacity = (value == 1) ? 0.999999 : (value === '') ? '' : (value < 0.00001) ? 0 : value;
		}
	}
	/**
	 * Apre un modal dialog (emulazione di - )
	 *
	 * @uses	Libero.Dialogs
	 * @see		Libero.Dialogs
	 * @param {Object} 	opener			elemento a cui appartiene il dialog (una window di solito)
	 * @param {Object} 	opts			Opzioni del dialog. L'unico elemento obbligatorio è l'url del contenuto (mdUrl)
	 *
	 * @return {Object}		Un oggetto di tipo Libero.Dialogs
	 */
	,
	openModalDialog: function(opener, opts){
		/*
		 * Opzioni obbligatorie (mutualmente esclusive: o l'una o l'altra):
		 mdUrl: '',					// Indirizzo completo della pagina da caricare all'interno
		 mdContent: false,			// Contenuto html da inserire al posto dell'iframe (Se false viene ignorato, e comunque l'url ha priorità)
		 * Opzioni Specificabili:
		 mdWidth: 600,				// Larghezza dialog
		 mdHeight: 300,				// Altezza dialog
		 mdClassPrefix: 'mdlg_',		// Prefisso dei nomi delle classi assegnate agli elementi del popup
		 mdIdPrefix: 'mdlg_',		// Prefisso degli di assegnati agli elementi
		 mdOffsetTop: 0,				// Spiazzamento verticale dall'alto rispetto al posizionamento centrale del popup
		 mdOffsetLeft: 0,			// Spiazzamento orizzontale da sinistra rispetto al posizionamento centrale del popup
		 mdFrameWidth: 3,			// Larghezza della cornice
		 mdBaseUrl: 'http://digistatic.libero.it/',	// Indirizzo del server statico di base per raggiungere i contenuti css e le immagini
		 mdCssUrl: 'css/mdlg/mdlg_default.css',	// Url del foglio di stile css da caricare per il layout del popup
		 mdButtonClose: {						// Tasto di chiusura'
		 offset_right: 3				// Spiazzamento orizzontale dal margine destro del contenuto
		 ,offset_top: 3				// Spiazzamento orizzontale dal margine superiore del contenuto
		 },
		 zIndex: 200000				// zIndex di base del dialog
		 */
		return new Libero.Dialogs(opener, opts);
	}
	/**
	 * Chiude un modal dialog
	 * @param {Object} mdlg				L'oggetto restituito dalla funzione openModalDialog
	 */
	,
	closeModalDialog: function(mdlg){
		return mdlg.close();
	}
	/**
	 * Crea un elemento dom associandolo all'oggetto libero
	 *
	 * @param {String} tagName			Tag dell'elemento da creare
	 * @param {String} className		Classe css da associare all'elemento
	 * @param {Object} bindAttrName	[opzionale]	Nome dell'attributo in cui settare l'oggetto
	 * @param {String} bindObj		[opzionale] Oggetto da "bindare" all'oggetto
	 * @return {Object}	L'oggetto inizializzato
	 */
	,
	createElement: function(tagName, className, bindAttrName, bindObj){
		var elem = document.createElement(tagName);
		elem.className = className;
		if (typeof(bindAttrName) != 'undefined' &&
		typeof(bindObj) != 'undefined' &&
		bindAttrName != null &&
		bindObj != null) {
			Libero.Utils.prototype.setBindedObjectToElement(elem, bindAttrName, bindObj);
		}
		return elem;
	}
	/**
	 * Lega ad un elemento dom un oggetto usando un nome attributo
	 * @param {Object} elem				Elemento dom a cui legare l'oggetto
	 * @param {Object} bindAttrName		Nome dell'attributo in cui settare l'oggetto
	 * @param {Object} bindObj			Oggetto da "bindare" all'oggetto
	 */
	,
	setBindedObjectToElement: function(elem, bindAttrName, bindObj){
		if (typeof(elem) != 'object') {
			elem = $(elem);
		}
		elem[bindAttrName] = bindObj;
	}
	/**
	 * Restituisce un oggetto precedentemente legato ad un elemento dom
	 * @param {Object} elem				Elemento Dom
	 * @param {Object} bindAttrName		Nome dell'attributo a cui è stato precedentemente legato un oggetto
	 */
	,
	getBindedObjectFromElement: function(elem, bindAttrName){
		if (typeof(elem) != 'object') {
			elem = $(elem);
		}
		return elem[bindAttrName];
	}
	/**
	 * Traduce una stringa contentente delle entities html
	 * nella stessa stringa in unicode
	 * @param {Object} strvalue
	 * return {String}
	 */
	,
	entities2unicode: function(strvalue){
		var matchEntities = /&(\w+?);/;
		while (matchEntities.test(strvalue)) {
			var match = strvalue.match(matchEntities);
			strvalue = strvalue.replace(matchEntities, this._entities2unicode_map[match[1]]);
		}
		return strvalue;
	}
	/**
	 * Traduce una stringa contentente delle entities html
	 * nella stessa stringa in unicode
	 * @param {Object} strvalue
	 * return {String}
	 */
	,
	unicode2entities: function(strvalue){
		var result = '', i, n = strvalue.length, c;
		for (i = 0; i < n; i++) {
			c = strvalue.charCodeAt(i);
			result += typeof(this._unicode2entities_map[c]) != 'undefined' ? '&' + this._unicode2entities_map[c] + ';' : strvalue.charAt(i);
		}
		return result;
	}
	/**
	 * Rapporto fra entities html e caratteri unicode
	 * @usedby	entities2unicode
	 */
	,
	_entities2unicode_map: {
		'nbsp': '\u00A0',
		'iexcl': '\u00A1',
		'cent': '\u00A2',
		'pound': '\u00A3',
		'curren': '\u00A4',
		'yen': '\u00A5',
		'brvbar': '\u00A6',
		'sect': '\u00A7',
		'uml': '\u00A8',
		'copy': '\u00A9',
		'ordf': '\u00AA',
		'laquo': '\u00AB',
		'not': '\u00AC',
		'shy': '\u00AD',
		'reg': '\u00AE',
		'macr': '\u00AF',
		'deg': '\u00B0',
		'plusmn': '\u00B1',
		'sup2': '\u00B2',
		'sup3': '\u00B3',
		'acute': '\u00B4',
		'micro': '\u00B5',
		'para': '\u00B6',
		'middot': '\u00B7',
		'cedil': '\u00B8',
		'sup1': '\u00B9',
		'ordm': '\u00BA',
		'raquo': '\u00BB',
		'frac14': '\u00BC',
		'frac12': '\u00BD',
		'frac34': '\u00BE',
		'iquest': '\u00BF',
		'Agrave': '\u00C0',
		'Aacute': '\u00C1',
		'Acirc': '\u00C2',
		'Atilde': '\u00C3',
		'Auml': '\u00C4',
		'Aring': '\u00C5',
		'AElig': '\u00C6',
		'Ccedil': '\u00C7',
		'Egrave': '\u00C8',
		'Eacute': '\u00C9',
		'Ecirc': '\u00CA',
		'Euml': '\u00CB',
		'Igrave': '\u00CC',
		'Iacute': '\u00CD',
		'Icirc': '\u00CE',
		'Iuml': '\u00CF',
		'ETH': '\u00D0',
		'Ntilde': '\u00D1',
		'Ograve': '\u00D2',
		'Oacute': '\u00D3',
		'Ocirc': '\u00D4',
		'Otilde': '\u00D5',
		'Ouml': '\u00D6',
		'times': '\u00D7',
		'Oslash': '\u00D8',
		'Ugrave': '\u00D9',
		'Uacute': '\u00DA',
		'Ucirc': '\u00DB',
		'Uuml': '\u00DC',
		'Yacute': '\u00DD',
		'THORN': '\u00DE',
		'szlig': '\u00DF',
		'agrave': '\u00E0',
		'aacute': '\u00E1',
		'acirc': '\u00E2',
		'atilde': '\u00E3',
		'auml': '\u00E4',
		'aring': '\u00E5',
		'aelig': '\u00E6',
		'ccedil': '\u00E7',
		'egrave': '\u00E8',
		'eacute': '\u00E9',
		'ecirc': '\u00EA',
		'euml': '\u00EB',
		'igrave': '\u00EC',
		'iacute': '\u00ED',
		'icirc': '\u00EE',
		'iuml': '\u00EF',
		'eth': '\u00F0',
		'ntilde': '\u00F1',
		'ograve': '\u00F2',
		'oacute': '\u00F3',
		'ocirc': '\u00F4',
		'otilde': '\u00F5',
		'ouml': '\u00F6',
		'divide': '\u00F7',
		'oslash': '\u00F8',
		'ugrave': '\u00F9',
		'uacute': '\u00FA',
		'ucirc': '\u00FB',
		'uuml': '\u00FC',
		'yacute': '\u00FD',
		'thorn': '\u00FE',
		'yuml': '\u00FF',
		'quot': '\u0022',
		'amp': '\u0026',
		'lt': '\u003C',
		'gt': '\u003E',
		'OElig': '',
		'oelig': '\u0153',
		'Scaron': '\u0160',
		'scaron': '\u0161',
		'Yuml': '\u0178',
		'circ': '\u02C6',
		'tilde': '\u02DC',
		'ensp': '\u2002',
		'emsp': '\u2003',
		'thinsp': '\u2009',
		'zwnj': '\u200C',
		'zwj': '\u200D',
		'lrm': '\u200E',
		'rlm': '\u200F',
		'ndash': '\u2013',
		'mdash': '\u2014',
		'lsquo': '\u2018',
		'rsquo': '\u2019',
		'sbquo': '\u201A',
		'ldquo': '\u201C',
		'rdquo': '\u201D',
		'bdquo': '\u201E',
		'dagger': '\u2020',
		'Dagger': '\u2021',
		'permil': '\u2030',
		'lsaquo': '\u2039',
		'rsaquo': '\u203A',
		'euro': '\u20AC',
		'fnof': '\u0192',
		'Alpha': '\u0391',
		'Beta': '\u0392',
		'Gamma': '\u0393',
		'Delta': '\u0394',
		'Epsilon': '\u0395',
		'Zeta': '\u0396',
		'Eta': '\u0397',
		'Theta': '\u0398',
		'Iota': '\u0399',
		'Kappa': '\u039A',
		'Lambda': '\u039B',
		'Mu': '\u039C',
		'Nu': '\u039D',
		'Xi': '\u039E',
		'Omicron': '\u039F',
		'Pi': '\u03A0',
		'Rho': '\u03A1',
		'Sigma': '\u03A3',
		'Tau': '\u03A4',
		'Upsilon': '\u03A5',
		'Phi': '\u03A6',
		'Chi': '\u03A7',
		'Psi': '\u03A8',
		'Omega': '\u03A9',
		'alpha': '\u03B1',
		'beta': '\u03B2',
		'gamma': '\u03B3',
		'delta': '\u03B4',
		'epsilon': '\u03B5',
		'zeta': '\u03B6',
		'eta': '\u03B7',
		'theta': '\u03B8',
		'iota': '\u03B9',
		'kappa': '\u03BA',
		'lambda': '\u03BB',
		'mu': '\u03BC',
		'nu': '\u03BD',
		'xi': '\u03BE',
		'omicron': '\u03BF',
		'pi': '\u03C0',
		'rho': '\u03C1',
		'sigmaf': '\u03C2',
		'sigma': '\u03C3',
		'tau': '\u03C4',
		'upsilon': '\u03C5',
		'phi': '\u03C6',
		'chi': '\u03C7',
		'psi': '\u03C8',
		'omega': '\u03C9',
		'thetasym': '\u03D1',
		'upsih': '\u03D2',
		'piv': '\u03D6',
		'bull': '\u2022',
		'hellip': '\u2026',
		'prime': '\u2032',
		'Prime': '\u2033',
		'oline': '\u203E',
		'frasl': '\u2044',
		'weierp': '\u2118',
		'image': '\u2111',
		'real': '\u211C',
		'trade': '\u2122',
		'alefsym': '\u2135',
		'larr': '\u2190',
		'uarr': '\u2191',
		'rarr': '\u2192',
		'darr': '\u2193',
		'harr': '\u2194',
		'crarr': '\u21B5',
		'lArr': '\u21D0',
		'uArr': '\u21D1',
		'rArr': '\u21D2',
		'dArr': '\u21D3',
		'hArr': '\u21D4',
		'forall': '\u2200',
		'part': '\u2202',
		'exist': '\u2203',
		'empty': '\u2205',
		'nabla': '\u2207',
		'isin': '\u2208',
		'notin': '\u2209',
		'ni': '\u220B',
		'prod': '\u220F',
		'sum': '\u2211',
		'minus': '\u2212',
		'lowast': '\u2217',
		'radic': '\u221A',
		'prop': '\u221D',
		'infin': '\u221E',
		'ang': '\u2220',
		'and': '\u2227',
		'or': '\u2228',
		'cap': '\u2229',
		'cup': '\u222A',
		'int': '\u222B',
		'there4': '\u2234',
		'sim': '\u223C',
		'cong': '\u2245',
		'asymp': '\u2248',
		'ne': '\u2260',
		'equiv': '\u2261',
		'le': '\u2264',
		'ge': '\u2265',
		'sub': '\u2282',
		'sup': '\u2283',
		'nsub': '\u2284',
		'sube': '\u2286',
		'supe': '\u2287',
		'oplus': '\u2295',
		'otimes': '\u2297',
		'perp': '\u22A5',
		'sdot': '\u22C5',
		'lceil': '\u2308',
		'rceil': '\u2309',
		'lfloor': '\u230A',
		'rfloor': '\u230B',
		'lang': '\u2329',
		'rang': '\u232A',
		'loz': '\u25CA',
		'spades': '\u2660',
		'clubs': '\u2663',
		'hearts': '\u2665',
		'diams': '\u2666'
	}
	/**
	 * Rapporto fra caratteri unicode e entities html
	 * @usedby	unicode2entities
	 */
	,
	_unicode2entities_map: {
		0x00A0: 'nbsp',
		0x00A1: 'iexcl',
		0x00A2: 'cent',
		0x00A3: 'pound',
		0x00A4: 'curren',
		0x00A5: 'yen',
		0x00A6: 'brvbar',
		0x00A7: 'sect',
		0x00A8: 'uml',
		0x00A9: 'copy',
		0x00AA: 'ordf',
		0x00AB: 'laquo',
		0x00AC: 'not',
		0x00AD: 'shy',
		0x00AE: 'reg',
		0x00AF: 'macr',
		0x00B0: 'deg',
		0x00B1: 'plusmn',
		0x00B2: 'sup2',
		0x00B3: 'sup3',
		0x00B4: 'acute',
		0x00B5: 'micro',
		0x00B6: 'para',
		0x00B7: 'middot',
		0x00B8: 'cedil',
		0x00B9: 'sup1',
		0x00BA: 'ordm',
		0x00BB: 'raquo',
		0x00BC: 'frac14',
		0x00BD: 'frac12',
		0x00BE: 'frac34',
		0x00BF: 'iquest',
		0x00C0: 'Agrave',
		0x00C1: 'Aacute',
		0x00C2: 'Acirc',
		0x00C3: 'Atilde',
		0x00C4: 'Auml',
		0x00C5: 'Aring',
		0x00C6: 'AElig',
		0x00C7: 'Ccedil',
		0x00C8: 'Egrave',
		0x00C9: 'Eacute',
		0x00CA: 'Ecirc',
		0x00CB: 'Euml',
		0x00CC: 'Igrave',
		0x00CD: 'Iacute',
		0x00CE: 'Icirc',
		0x00CF: 'Iuml',
		0x00D0: 'ETH',
		0x00D1: 'Ntilde',
		0x00D2: 'Ograve',
		0x00D3: 'Oacute',
		0x00D4: 'Ocirc',
		0x00D5: 'Otilde',
		0x00D6: 'Ouml',
		0x00D7: 'times',
		0x00D8: 'Oslash',
		0x00D9: 'Ugrave',
		0x00DA: 'Uacute',
		0x00DB: 'Ucirc',
		0x00DC: 'Uuml',
		0x00DD: 'Yacute',
		0x00DE: 'THORN',
		0x00DF: 'szlig',
		0x00E0: 'agrave',
		0x00E1: 'aacute',
		0x00E2: 'acirc',
		0x00E3: 'atilde',
		0x00E4: 'auml',
		0x00E5: 'aring',
		0x00E6: 'aelig',
		0x00E7: 'ccedil',
		0x00E8: 'egrave',
		0x00E9: 'eacute',
		0x00EA: 'ecirc',
		0x00EB: 'euml',
		0x00EC: 'igrave',
		0x00ED: 'iacute',
		0x00EE: 'icirc',
		0x00EF: 'iuml',
		0x00F0: 'eth',
		0x00F1: 'ntilde',
		0x00F2: 'ograve',
		0x00F3: 'oacute',
		0x00F4: 'ocirc',
		0x00F5: 'otilde',
		0x00F6: 'ouml',
		0x00F7: 'divide',
		0x00F8: 'oslash',
		0x00F9: 'ugrave',
		0x00FA: 'uacute',
		0x00FB: 'ucirc',
		0x00FC: 'uuml',
		0x00FD: 'yacute',
		0x00FE: 'thorn',
		0x00FF: 'yuml',
		0x0022: 'quot',
		0x0026: 'amp',
		0x003C: 'lt',
		0x003E: 'gt',
		0x0153: 'oelig',
		0x0160: 'Scaron',
		0x0161: 'scaron',
		0x0178: 'Yuml',
		0x02C6: 'circ',
		0x02DC: 'tilde',
		0x2002: 'ensp',
		0x2003: 'emsp',
		0x2009: 'thinsp',
		0x200C: 'zwnj',
		0x200D: 'zwj',
		0x200E: 'lrm',
		0x200F: 'rlm',
		0x2013: 'ndash',
		0x2014: 'mdash',
		0x2018: 'lsquo',
		0x2019: 'rsquo',
		0x201A: 'sbquo',
		0x201C: 'ldquo',
		0x201D: 'rdquo',
		0x201E: 'bdquo',
		0x2020: 'dagger',
		0x2021: 'Dagger',
		0x2030: 'permil',
		0x2039: 'lsaquo',
		0x203A: 'rsaquo',
		0x20AC: 'euro',
		0x0192: 'fnof',
		0x0391: 'Alpha',
		0x0392: 'Beta',
		0x0393: 'Gamma',
		0x0394: 'Delta',
		0x0395: 'Epsilon',
		0x0396: 'Zeta',
		0x0397: 'Eta',
		0x0398: 'Theta',
		0x0399: 'Iota',
		0x039A: 'Kappa',
		0x039B: 'Lambda',
		0x039C: 'Mu',
		0x039D: 'Nu',
		0x039E: 'Xi',
		0x039F: 'Omicron',
		0x03A0: 'Pi',
		0x03A1: 'Rho',
		0x03A3: 'Sigma',
		0x03A4: 'Tau',
		0x03A5: 'Upsilon',
		0x03A6: 'Phi',
		0x03A7: 'Chi',
		0x03A8: 'Psi',
		0x03A9: 'Omega',
		0x03B1: 'alpha',
		0x03B2: 'beta',
		0x03B3: 'gamma',
		0x03B4: 'delta',
		0x03B5: 'epsilon',
		0x03B6: 'zeta',
		0x03B7: 'eta',
		0x03B8: 'theta',
		0x03B9: 'iota',
		0x03BA: 'kappa',
		0x03BB: 'lambda',
		0x03BC: 'mu',
		0x03BD: 'nu',
		0x03BE: 'xi',
		0x03BF: 'omicron',
		0x03C0: 'pi',
		0x03C1: 'rho',
		0x03C2: 'sigmaf',
		0x03C3: 'sigma',
		0x03C4: 'tau',
		0x03C5: 'upsilon',
		0x03C6: 'phi',
		0x03C7: 'chi',
		0x03C8: 'psi',
		0x03C9: 'omega',
		0x03D1: 'thetasym',
		0x03D2: 'upsih',
		0x03D6: 'piv',
		0x2022: 'bull',
		0x2026: 'hellip',
		0x2032: 'prime',
		0x2033: 'Prime',
		0x203E: 'oline',
		0x2044: 'frasl',
		0x2118: 'weierp',
		0x2111: 'image',
		0x211C: 'real',
		0x2122: 'trade',
		0x2135: 'alefsym',
		0x2190: 'larr',
		0x2191: 'uarr',
		0x2192: 'rarr',
		0x2193: 'darr',
		0x2194: 'harr',
		0x21B5: 'crarr',
		0x21D0: 'lArr',
		0x21D1: 'uArr',
		0x21D2: 'rArr',
		0x21D3: 'dArr',
		0x21D4: 'hArr',
		0x2200: 'forall',
		0x2202: 'part',
		0x2203: 'exist',
		0x2205: 'empty',
		0x2207: 'nabla',
		0x2208: 'isin',
		0x2209: 'notin',
		0x220B: 'ni',
		0x220F: 'prod',
		0x2211: 'sum',
		0x2212: 'minus',
		0x2217: 'lowast',
		0x221A: 'radic',
		0x221D: 'prop',
		0x221E: 'infin',
		0x2220: 'ang',
		0x2227: 'and',
		0x2228: 'or',
		0x2229: 'cap',
		0x222A: 'cup',
		0x222B: 'int',
		0x2234: 'there4',
		0x223C: 'sim',
		0x2245: 'cong',
		0x2248: 'asymp',
		0x2260: 'ne',
		0x2261: 'equiv',
		0x2264: 'le',
		0x2265: 'ge',
		0x2282: 'sub',
		0x2283: 'sup',
		0x2284: 'nsub',
		0x2286: 'sube',
		0x2287: 'supe',
		0x2295: 'oplus',
		0x2297: 'otimes',
		0x22A5: 'perp',
		0x22C5: 'sdot',
		0x2308: 'lceil',
		0x2309: 'rceil',
		0x230A: 'lfloor',
		0x230B: 'rfloor',
		0x2329: 'lang',
		0x232A: 'rang',
		0x25CA: 'loz',
		0x2660: 'spades',
		0x2663: 'clubs',
		0x2665: 'hearts',
		0x2666: 'diams'
	}
};
/**
 * Classe root per gli effetti di transizione
 */
Libero.Transitions = Class.create();
Libero.Transitions.prototype = {
	trType: null, // Tipo di transizione
	TRANS_TYPE_CROSSFADE: 0,	// Costante: Tipo di transizione Crossfade
	TRANS_TYPE_CURTAIN: 1,		// Costante: Tipo di transizione tendina
	initialize: function(opts){
	}
};