/************ 
	after.js : 	Fichier JS qui doit être appelé à la fin de la page, cela permet une arrivée plus rapide de la page.
*************/

/** *********************************************************************************************************
    REMPLACEMENT DES METHODES getElementById ET getElementsByTagName
    EXEMPLES :
	var oEl = $('test');              // retourne l'objet ayant l'id 'test'
	var oEl2 = $(oEl);               // retourne oEl
	var aEls = $(oEl, 'a');         // retourne tous les liens de oEl
	var aEls2 = $('test', 'a');    // retourne tous les liens du conteneur ayant pour id 'test'
	var oEl3 = $(oEl, 'a')[0];    // retourne le premier lien de oEl
*/

var $ = {
	select: function() {
		var aArgs = arguments;
		if(aArgs.length > 1 && typeof aArgs[1] == 'string') {
			return typeof aArgs[0] == 'string' ?
				document.getElementById(aArgs[0]).getElementsByTagName(aArgs[1]) :
				aArgs[0].getElementsByTagName(aArgs[1]);
		}
		else switch(typeof aArgs[0]) {
			case 'string':
				return document.getElementById(aArgs[0]);
			case 'object':
				return aArgs[0];
		}
		return false;
	}
};
$ = $.select;

/** *********************************************************************************************************
     FONCTION D'EXTENTION DE PROPRIETES D'UN OBJET - Extrait de Mootools
     EXEMPLES :
	$extend(myObj, {alerte: function(sMsg) { alert(sMsg); });      //  Ajout de la methode alerte a l'objet myObj
	$extend(myObj, anotherObj);                                             //  Ajout des methodes de l'objet anotherObj a l'objet myObj
*/
if (!window.$extend) {
	function $extend(original, extended){
		for (var key in (extended || {})) original[key] = extended[key];
		return original;
	};
}
function $protoTypeExtend(original, extended){
	for (var key in (extended || {})) {
		if (!original[key]) original[key] = extended[key];
	}
	return original;
};

/************************************
* EXTENSION PROTOTYPES
**************************************/
$protoTypeExtend(Array.prototype, {
	each: function(f) {
		var i;
		for(var i=0;i<this.length;i++) {
			f(this[i]);
		}
	},
	eachInv: function(f) {
		for(var i=this.length-1;i>=0;i--) {
			f(this[i]);
		}
	},
	last: function() {
		return this.length>0 ? this[this.length-1] : null;
	}
});

/** *********************************************************************************************************
    GESTIONNAIRE D'EVENEMENT
    EXEMPLES :
	$e.add('domready', alerte);                                                    // Lance le gestionnaire alerte au chargement de la page
	$e.add(oEl, 'click', alerte);                                                     // Ajoute le gestionnaire alerte au clic sur oEl en mode 'effervescence'
	$e.add(oEl, 'click', alerte, true);                                             // Ajoute le gestionnaire alerte au clic sur oEl en mode 'capture' (IE ne sait pas faire)
	$e.remove(oEl, 'click', alerte);                                               // Supprime le gestionnaire alerte au clic sur oEl
	$e.add(oEl, 'click', function(e) { $e.stop(e); });                        // Si oEl est un lien, $e.stop(e); stoppe la transmission de l'evenement et annule l'action normale du lien
	$e.add(oEl, 'click', function(e) { alert($e.getSrc(e)); });            // Retourne la source de l'evenement
	$e.add(oEl, 'mouseover', function(e) { alert($e.relSrc(e)); });    // Retourne l'element survole precedent le mouseover
	$e.add(oEl, 'mouseout', function(e) { alert($e.relSrc(e)); });     // Retourne l'element survole suivant le mouseout
*/


var $e = {
	domReadyFunctions : [],
	onloadFunctions : [],
	onloadInit : false,
	domreadyExecuted: false,
	domReadyInit : false,
	// Ajout d'un gestionnaire d'evenement sur un element lors d'un evenement donne
	add: function(oElemOrEvent, sEvType, fn, bCapture) {
		var a = arguments;
		if(oElemOrEvent == 'domready')
			return $e.domready(sEvType);
		if (oElemOrEvent==window && sEvType=='load') {
			$e.addOnLoad(fn);
			if (!$e.onloadInit) {
				$e.onloadInit = true;
				$e.addEvent(window, 'load', $e.onLoadExecute, bCapture)
				return;
			}
			return;
		}
		return $e.addEvent(oElemOrEvent, sEvType, fn, bCapture);
	},
	
	addEvent : function(oElemOrEvent, sEvType, fn, bCapture) {
		return document.addEventListener ?
			oElemOrEvent.addEventListener(sEvType, fn, bCapture || false):
			oElemOrEvent.attachEvent ? 
				oElemOrEvent.attachEvent('on' + sEvType, fn) :
				false;
	},
	// Suppression d'un gestionnaire d'evenement sur un element pour un evenement donne
	remove: function(oElem, sEvType, fn, bCapture) {
		return document.addEventListener ?
			oElem.removeEventListener(sEvType, fn, bCapture || false):
			oElem.detachEvent ?
				oElem.detachEvent('on' + sEvType, fn):
				false;
	},
	// Annulation de la propagation d'un evenement et de l'action par defaut d'un element
	stop: function(e) {
		if(e && e.stopPropagation && e.preventDefault) {
			e.stopPropagation();
			e.preventDefault();
		}
		else if(e && window.event) {
			window.event.cancelBubble = true;
			window.event.returnValue = false;
		}
		return false; // Indispensable pour Safari
	},
	// Retourne la source de l'evenement
	getSrc: function(e) {
		return e.target || e.srcElement;
	},
	relSrc: function(e) {
		switch(e.type) {
			case 'mouseover': // Retourne l'element survole precedent l'element source de l'evenement
				return e.relatedTarget || e.fromElement;
			case 'mouseout': // Retourne l'element survole suivant l'element source de l'evenement
				return e.relatedTarget || e.toElement;
		}
	},
	// Detecte le chargement du DOM - http://dean.edwards.name/weblog/2006/06/again/#comment5338
	domready: function(fn) {
		if (!$e.domReadyInit) {
			// Internet Explorer 
			if(window.attachEvent) {
				document.write('<script id="ieScriptLoad" defer src="//:javascript:void(0)"><\/script>');
				document.getElementById('ieScriptLoad').onreadystatechange = function() {
					if(this.readyState == 'complete')
						$e.init($e.domReadyExecute);
				};
			}
			// Mozilla/Opera 9 
			if(document.addEventListener)
				document.addEventListener('DOMContentLoaded', function() { $e.init($e.domReadyExecute); }, false);
			// Safari 
			if(navigator.userAgent.search(/WebKit/i) != -1){
			    $e.loadTimer = setInterval(function (){
					if(document.readyState.search(/loaded|complete/i) != -1)
						$e.init($e.domReadyExecute);
				}, 10);
			}
			// Other web browsers
			if($e)
				$e.addEvent(window,'load', function() { $e.init($e.domReadyExecute); });
			$e.domReadyInit = true;
		}
		$e.domReadyFunctions.push(fn);
	},
	
	addOnLoad : function(fn) {
		$e.onloadFunctions.push(fn);
	},
	
	domReadyExecute : function() {
		if ($e.domreadyExecuted) return;
		$e.domreadyExecuted = true;
		for (var i=0; i<$e.domReadyFunctions.length; i++) {
			$e.domReadyFunctions[i]();
		}
	},
	
	onLoadExecute : function() {
		if (!$e.domreadyExecuted)
			$e.domReadyExecute();
		for (var i=0; i<$e.onloadFunctions.length; i++)
			$e.onloadFunctions[i]();
	},

	// Initialise le script
	init: function(fn) {
		if (arguments.callee.done) return;
		arguments.callee.done = true;
		if ($e.loadTimer) clearInterval($e.loadTimer);
			fn();
	}
};

/** *********************************************************************************************************
    GESTIONNAIRE DE STYLES
*/

var $s = {
	// Retourne la valeur d'une propriete CSS appliquee a un element
	get: function(oElm, strCssRule) {
		var strValue = "";
		if(document.defaultView && document.defaultView.getComputedStyle) {
			try{
				strValue = document.defaultView.getComputedStyle(oElm, null).getPropertyValue(strCssRule);
			}
			catch(e) { strValue = ""; }
		}
		else if(oElm.currentStyle) {
			try{
				strCssRule = strCssRule.replace(/\-(\w)/g, function (strMatch, p1){
					return p1.toUpperCase();
				});
				strValue = oElm.currentStyle[strCssRule];
			} catch(e) {
				strValue = "";
			}
		}
		return strValue;
	},
	// Retourne la valeur entiere d'un style
	integer: function(oElm, strCSSRule) {
		var val = parseInt($s.get(oElm, strCSSRule));
		if (isNaN(val)) val=0;
		return val;
	},
	// Retourne la somme de tous les styles verticaux appliques (border-width+padding)
	getV: function(elm) {
		return navigator.quirksMode ?
			0 :
			$s.integer(elm, "padding-top") + $s.integer(elm, "padding-bottom") +
			$s.integer(elm, "border-top-width") + $s.integer(elm, "border-bottom-width");
	},
	// Retourne la somme de tous les styles horizontaux appliques (border-width+padding)
	getH: function(elm) {
		return navigator.quirksMode ?
			0 :
			$s.integer(elm, "padding-left") + $s.integer(elm, "padding-right") +
			$s.integer(elm, "border-left-width") + $s.integer(elm, "border-right-width");
	}
};




/**********
* $n : objet de parcours du DOM, facile. Les fonctions ne font que les nodes HTML
***********/
var $n = {
	/* 	hasAttributes : retourne true si l'element passe en parametre correspond a tous les attributs passes, on peut aussi donner des attributs que l'on ne veut pas, afin de filtrer tous les elements
		ex : if (hasAttributes(div, {nodeName:"div", className:"foobar"), {className:"idontwant"} ) doStuff();
		ici on recherche tous les DIV qui on la classe "foobar", mais on ne prend pas ceux qui ont la classe "idontwant" ex : <div class="foobar idontwant"> ne sera pas recupere.
	*/
	hasAttr : function(n, a, not) {
		var re, at;
		if (n.nodeType!=1) return false;
		function check(attr) {
			for (var i in attr) {
				at = (typeof n[i]) !="undefined" ? n[i] : n.getAttribute(i);
				re = attr[i] instanceof RegExp ? attr[i] : new RegExp("\\b" + attr[i] + "\\b","i");
				if (!at || !re.test(at))
					return false;
			}
			return true;
		};
		if (not && check(not))	return false;
		if (check(a)) return true;
		return false;
	},
	/* getByTagName : equivalent a element.getElementsByTagName, mais compatible avec IE5 et IE5.5 pour l'histoire du "*" */
	getByTagName : function(n, tag) {
		return  (tag=="*") ? (n.all ? n.all : n.getElementsByTagName("*")) : n.getElementsByTagName(tag);
	},
	/* fonction qui retourne le premier element correspondant aux attributs donnes */
	node : function(n, a, not) {
		return $n.nodes(n, a, not, true);
	},
	/* fonction qui retourne tous les elements correspondant selon "a" */
	nodes : function(n, a, not, oneNode, arrElms, invertSens) {
		var aRetElms=[];
		if (!a) a = {};
		if (typeof a == "string") a = {nodeName:a}; //si une chaine de caracteres passee en parametre, cela signifie qu'on ne veut que recuperer des tags
		if (a.nodeName && a.nodeName=="*") delete a.nodeName;
		var elms = arrElms || $n.getByTagName(n, (a.nodeName || "*"));
		var forFunc = function(elms, i) {
			var x = elms[i];
			if ($n.hasAttr(x, a, not)) {
				if (oneNode) return x;
				else aRetElms.push(x);
			}
			return null;
		}
		if (invertSens) {
			for (var i=elms.length-1; i>=0; i--) {
				var x = forFunc(elms, i);
				if (x) return x;
			}
		} else {
			for (var i=0; i<elms.length; i++) {
				var x = forFunc(elms, i);
				if (x) return x;
			}
		}
		if (oneNode) return null;
		return aRetElms;
	},
	/* childs : retourne tous les noeuds enfants de l'element  */
	childs : function(n, a, not) {
		return $n.nodes(n, a, not, false, n.childNodes);
	},
	firstChild : function(n, a, not) {
		return $n.nodes(n, a, not, true, n.childNodes);
	},
	lastChild : function(n, a, not) {
		var node = $n.nodes(n, a, not, true, n.childNodes, true);
		return node;
	},
	move : function(n, a, not, action) {
		while (n) {
			if ($n.hasAttr(n, a, not)) return n;
			n = n[action];
		}
		return null;
	},
	after : function(n, a, not) {
		return $n.move(n, a, not, "nextSibling");
	},
	before : function(n, a, not) {
		return $n.move(n, a, not, "previousSibling");
	},
	parent : function(n, a, not) {
		return $n.move(n, a, not, "parentNode");
	}
}

/********
* Layer 
********/
var $layer = {
	options : {
		id : 'insidePopup',
		templateHTML : '<div class="insidePopupContent">__CONTENT__</div>',
		styles : {
			width: '300px', height: '200px',
			left:0, top:0
		},
		position: 'center', // pour l'instant il ne prend que center et sera developpé plus tard pour prendre les valeurs left/right/center et top/bottom/center avec les combo 'left top', 'right top' etc, etc 
		mask : false, //mask sous la layer
		maskPosition : null, // element HTML sur lequel le mask s'appliquera, si null, le parent le plus haut sera pris (<body>)
		content : '', //code HTML pour remplir le layer
		parent : null, //le parent du layer, par defaut c'est document.body
		fixLayerOnParent : false, // si on veut placer le layer au dessus d'un élément, on peut spécifier si on met le position:relative ou pas
		className : "" //une classe CSS posée sur la popup afin de customiser la popup si nécessaire
	},
	currentOptions : {},
	resetOptions : function() {this.currentOptions = {}; $extend(this.currentOptions, this.options);},	
	open : function(options) {
		this.close();
		this.resetOptions();
		if (options.styles.opacity!=null) options.styles.filter = 'alpha(opacity='+options.styles.opacity*100+')'; // compatible IE
		this.currentOptions = $extend(this.currentOptions, options);
		if (!$(this.currentOptions.id))  this.createLayer();
		if (this.currentOptions.mask)  this.createMask();
		this.layer.innerHTML = this.layer.innerHTML.replace(/__CONTENT__/g, this.currentOptions.content);
		this.initActionsButtonsOnLayer();
		
		this.layer.style.width = this.layer.clientWidth - $s.getH(this.layer) + 'px';
		this.setSize();
		this.setPosition();
		$e.add(window, 'resize', this.refreshSizeAndPosition);
		this.refreshSizeAndPosition();
		this.layer.style.visibility = 'visible';
	},
	close : function() {
		if ($(this.currentOptions.id)) {
			$(this.currentOptions.id).parentNode.removeChild($(this.currentOptions.id));
		}
		if (this.currentOptions.parent) 
			this.currentOptions.parent.style.height  = '';
		if (this.mask) 
			this.mask.parentNode.removeChild(this.mask);
		
		try {
			delete this.layer;
			delete this.content;
			delete this.mask;
		} catch(e) {}
		if (typeof CollectGarbage == 'function') {
		  CollectGarbage();
		}
		$e.remove(window, 'resize', this.refreshSizeAndPosition);
	},
	createLayer : function() { 
		var layer = document.createElement('div');
		layer.className += ' '+this.currentOptions.className || "";
		layer.id = this.currentOptions.id;
		$extend(layer.style, this.currentOptions.styles);
		$extend(layer.style, {left:0, top:0, display:'block', visibility:'hidden'});
		layer.innerHTML = this.currentOptions.templateHTML;
		if (this.currentOptions.over) {
			this.currentOptions.parent.appendChild(layer);
			if (this.currentOptions.fixLayerOnParent) {
				this.currentOptions.parent.style.position = 'relative';
			} else 
				this.currentOptions.position = 'byElement';
		} else 
			document.body.appendChild(layer);
		this.layer = layer;
		this.layerContent = $n.node(layer, {nodeName:'div', className:'insidePopupContent'});
		return this.layer;
	},
	createMask : function() {
		var mask  = document.createElement('div');
		mask.id = 'insidePopupMask';
		document.body.appendChild(mask);
		this.mask = mask;
	},
	setPosition : function() {
		var styles = {};
		var currStyles = this.currentOptions.styles;
		switch(this.currentOptions.position) {
			case 'center' : 
				styles = {
					left : (document.documentElement.clientWidth-this.layer.offsetWidth)/2+document.documentElement.scrollLeft+'px',
					top: (document.documentElement.clientHeight-this.layer.offsetHeight)/2+document.documentElement.scrollTop+'px'
				};
				break;
			case 'user' :
				styles = {
					left : currStyles.left,
					top : currStyles.top
				}
				break;
			case 'byElement' : 	
				styles = {
					left : this.currentOptions.over.offsetLeft+'px',
					top : this.currentOptions.over.offsetTop+'px'
				};
				break;
			default : 
				break;
		}
		$extend(this.layer.style, styles);
	},
	setSize : function() {
		if (!isNaN(parseInt(this.currentOptions.styles.height))) {
			this.layer.style.height = 'auto';
			var inside = $n.node(this.layer, {nodeName:'div', className:'insidePopupContent'});
			if (this.currentOptions.parent && inside && $s.get(inside, 'position')!='absolute' && inside.offsetHeight > this.currentOptions.parent.offsetHeight) {
				this.currentOptions.parent.style.height = this.layer.offsetHeight+'px';
			} 
			if (this.layer.offsetHeight<parseInt(this.currentOptions.styles.height))
				this.layer.style.height = parseInt(this.currentOptions.styles.height)-$s.getV(this.layer)+'px';
		}
	},
	refreshSizeAndPosition : function() {
		if ($layer.currentOptions.position=='center')
			$layer.setPosition();
		if ($layer.mask) 
			$extend($layer.mask.style, {
				height : (document.body.clientHeight < document.documentElement.clientHeight ? document.documentElement.clientHeight : document.body.scrollHeight)+'px',
				width : document.documentElement.scrollWidth > document.documentElement.clientWidth ? document.documentElement.scrollWidth+'px' : "100%"
			})
	},
	initActionsButtonsOnLayer : function() {
		var closeButtons = $n.nodes(this.layer, {nodeName:'a', className:'insidePopupCloseButton'});
		closeButtons.each(function(btn) {
			btn.onclick = function() {
				$layer.close();
				return false;
			}
		})
	}
}

function pngFix(elm, noOverflow) {
	elm.style.filter = ' ';
	if (!(document.all && window.print && /MSIE [56]/.test(navigator.userAgent))) return;
	var exec = (function(elm, noOverflow, scale) {
		return function() {
			var options = { noOverflow:noOverflow};
			var repeat = elm.currentStyle.backgroundRepeat.toLowerCase()=='repeat';
			elm.style.filter = ' ';
				// si l'élément est un tag img, on va en faire creer une balise qui encadrera cette image et ensuite traiter la balise comme si c'etait un élément qui avait une image de fond
				if (elm.nodeName.match(/^(IMG|INPUT)$/)) {
					if (!elm.src.match(/.*\.png$/)) return;
					
					elm.style.filter="progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod='image', src='"+ elm.src + "')";
					
					elm.width = elm.offsetWidth;
					elm.height = elm.offsetHeight;
					
					/* recuperation de l'url du pixel transparent */
					var url = elm.currentStyle.backgroundImage.match(/^url\(["'](.*\.gif)["']\)$/); //seulement les .png
					elm.src = url[1];
					elm.className = elm.className.replace(/pngFix/g,'');
					
				}
				else {
				
				
					if (elm.currentStyle.backgroundImage == "" || elm.currentStyle.backgroundImage == "url()") return;
					var url = elm.currentStyle.backgroundImage.match(/^url\(["'](.*\.png)["']\)$/); //seulement les .png
					if (!url || url.length<2) return;
					var pngLayer = document.createElement('i'); // on genere un <i> en position:absolute (layer), qui viendra se placer sous le contenu du div  qui avait besoin du style.
					with(pngLayer.style) {
						if (options.noOverflow) {
							width = elm.offsetWidth + 'px';
							height = elm.offsetHeight + 'px';
						} else {
						 	width = '32000px';
							height = '32000px'; 
						}
						position = 'absolute';
						zIndex = -1;
						fontSize = '1%';
						filter="progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod='" + (options.noOverflow ? 'crop' : 'image') + "', src='"+url[1]+"')";
						background = 'none'; //forcing car parfois il peut arriver qu'on ai une CSS qui vienne rajouter des images / couleurs de fond
						/* positionnement de l'image en fonction du background-position sur l'element */
						if (!repeat) {
							switch((elm.currentStyle.backgroundPositionX+'').toLowerCase()) {
								case 'left' : left=0; break; 
								case 'right' : right = 0; break;
								case 'center' : 
									left='50%'; 
									setTimeout(function(pngLayer) {
										return function() {
											pngLayer.style.marginLeft = -(pngLayer.offsetWidth/2)+'px'; 
										}
									}(pngLayer), 50);
									break;
								default : 
									left = elm.currentStyle.backgroundPositionX; 
							}

							switch((elm.currentStyle.backgroundPositionY+'').toLowerCase()) {
								case 'top' : top = 0; break;
								case 'bottom' : bottom = 0; break;
								case 'center' : 
									top='50%'; 
									setTimeout(function(pngLayer) {
										return function() {
											pngLayer.style.marginTop=-(pngLayer.offsetHeight/2)+'px'; 
										}
									}(pngLayer), 100);
									break;
								default : 
									top = elm.currentStyle.backgroundPositionY || 0; 
							}
						} else {
							left = 0; //elm.currentStyle.backgroundPositionX +'';
							top = 0; //elm.currentStyle.backgroundPositionY +'';
						}
					} 
					
						/* gestion automatique du sizingMethod='scale' ou sizingMethod='image', ne pouvant pas tester le backgroundRepeat correctement, on passe par une methode un peu plus tricky */
						setTimeout(function(elmN, pngLayerN, repeatN) {
							return function() {
								if (pngLayerN.filters['DXImageTransform.Microsoft.AlphaImageLoader'].sizingMethod=='image') {
									if (pngLayerN.offsetWidth<elmN.offsetWidth && repeatN) {
										pngLayerN.filters['DXImageTransform.Microsoft.AlphaImageLoader'].sizingMethod='scale';
									} else if (pngLayerN.offsetWidth>elmN.offsetWidth && elm.currentStyle.backgroundPositionX.match(/^(left|0%|0px|0)$/) || elm.currentStyle.backgroundPositionY.match(/^(top|0%|0px|0)$/)){
										pngLayerN.filters['DXImageTransform.Microsoft.AlphaImageLoader'].sizingMethod='crop';
									}
								} else {
									pngLayerN.sizingMethod = 'image';
								}
								if (elm.currentStyle.width.match(/^(0|[12](%|px)?)$/)) {
									pngLayerN.filters['DXImageTransform.Microsoft.AlphaImageLoader'].sizingMethod='image';
								}
								if (pngLayerN.style.right != 'auto' && pngLayerN.style.right !='')
									setTimeout(function() {
										pngLayerN.style.right = parseInt(pngLayerN.style.right) - (elm.offsetWidth%2 ? 1 : 0) + 'px';
									}, 50)
							}
						}(elm, pngLayer, repeat), 200);
					
					with (elm.style) {
						position = elm.currentStyle.position=="static" || elm.currentStyle.position=="" ? 'relative' : position;
						if (elm.currentStyle.overflow!='auto' && elm.currentStyle.overflow!='hidden') overflow = options.noOverflow ? 'visible' : (elm.currentStyle.width.match(/^(0|[12](%|px)?)$/) ? 'visible' : 'hidden');
						backgroundImage = 'none';
					}
					elm.appendChild(pngLayer);
			}
		}
	})(elm, noOverflow);
	try{
		pngFixLoader.useOnload ? pngFixLoader.addFunc(exec) : exec();
	} catch(e) {};
}



/* pngFixLoader 
	@unction 		:	objet pour permet le lancement des modifications des png via pngFix en décalé sur le onload de la page.
							cela permet de contourner un bug d'internet explorer qui affiche un message d'erreur si le DOM est modifié pendant le chargement de la page.
*/
var pngFixLoader = {
	useOnload : true, // true : active l'execution du fixPng sur le load, et false, execute le fixPng dès qu'il est appelé par la CSS
	functions : [], // toutes les fonctions à éxécuter sur le onload de la page
	addFunc : function(func) {
		pngFixLoader.functions.push(func);
	},
	launch : function() {
			pngFixLoader.useOnload = false; //une fois la page chargée, il faut laisser s'executer automatiquement la fonction pour d'autres actions (ex : ouverture layer)
			var counter = 1;
			while(pngFixLoader.functions.length>0) {
				//setTimeout(pngFixLoader.functions.pop(), 20*counter);
				pngFixLoader.functions.pop()();
				counter++;
			}
	},
	init : function() {
		if (pngFixLoader.useOnload) {
			setTimeout(pngFixLoader.launch, 100);
			
		}
	}
}
pngFixLoader.init();

var showLayerInformation = function(text){
	$layer.open({
		position:'center', 
		styles:{
			width:'400px'
		},
		mask : true,
		content : [
			'<div class="blockLayer">',
			'	<span class="tl">',
			'		<span class="tr">',
			'			<a class="insidePopupCloseButton" onclick="$layer.close();" href="#">Fermer</a>',
			'		</span>',
			'	</span>',
			'	<div class="body inscription">',
			text ? text : '',
			'	</div>',
			'	<span class="bl">',
			'		<span class="br"/>',
			'	</span>',
			'</div>',
			].join('')
	});
}