(function() {
	var path = '/js/';
	var ts = (new Date()).getTime();
	var scripts = [
		'FW.core.js',
		'FW.decorations.js',
		'objects.js',
		'FW.modules.js',
		'FW.main.js'
		];
	
	for (var i=0; i<scripts.length; i++) {
		document.write('<script type="text/javascript" src="' + path + scripts[i] + '" ></script>');
	}
	
})();


/**
**
**/

/*	fixPng :
	@function 	: 	fixe les images de fond png 24 bits sous IE6 (pour la transparent alpha) ainsi que les tags <img>
    @desc 			: 	cette fonction est appel?e par la CSS pour un ?l?ment qui a un PNG24Bits en background,
							Un ?l?ment (<i> dans notre cas) est g?n?r? et mis en position:absolute avec z-index:-1 et des largeur/hauteur de 32000px, celui-ci contiendra l'image en PNG.afin de g?rer les ?l?ment extensible.
							Cette m?thode a ?t? utilis?e afin de ne page avoir le bug ou certains contenus se retrouve d?sactiv? (liens) lorsqu'on utilise le filter sur un ?l?ment.
							L'?l?ment conteneur se verra appliqu? un position:relative (si position de base est 'static') et un overflow:hidden afin de bien cacher le le d?passement de l'?m?net qui contient l'image.
							Si on ne veut pas utiliser l'overflow:hidden ou on veut utiliser la methode 'crop' il est possible de passer des parametres ? la fonction (cf @params)
							Fonctionne aussi avec les tag <img> on le n?cessaire est faire pour remplacer l'image, sans la d?sactiver (cf @additional)
	@use				:   A utiliser dans la CSS, ex :
							.myclass{
								background:url('skin/nav/backgroundnav.png) no-repeat left top;
								filter:expression(pngFix(this));
							}

							ou
							img.laclassespecifiqueacetteimage {filter:expression(pngFix(this));}

	@params		:	pngFix(element:HTMLElement, noOverflow:boolean, scale:boolean);
							- element : element HTML : passer  this dans la CSS.
							- noOverflow (true) :	par defaut on utilise un overflow:hidden, sur le parent conteneur, si cela, g?ne,
																il suffit de passer la valeur true pour ce parametre, et automatiquement on utilisera un overflow:visible;
	@additional	: G?re aussi les tag <img> qui seront automatiquement transform?s en image avec transparence PNG.
							En utilisant la m?thode de base  (appel au filter), l'image est automatiquement g?r?e.
							Mais si on veut faire du cas par cas, il suffit de cr?er une classe CSS appel?e pngFix, qui sera ensuite pos?e sur les tags <img>
								img.pngFix {filter:expression(pngFix(this));}
								<img src="img/myImage.png" class="pngFix" />
	@exemples	:
						- filter:expression(pngFix(this))  //==> mode normal, un layer contenant le png dans le fond, est mis sur l'?l?ment avec comme avantage
																				de pouvoir utiliser une image tr?s grande, et automatiquement,
																				le bloc peut etre extensible en largeur + hauteur.
						- filter:expression(pngFix(this, null, true))  //==> l'image prend toute la taille du bloc, ce qui est utile par exemple pour simuler un png r?p?t? sous les autres navigateurs
						- filter:expression(pngFix(this, true))  //==> on ne change que l'overflow par visible, ce qui du coup ne permet plus d'avoir un bloc extensible ? 100% en largeur


						.maClass {background:url(/img/monimage.png) no-repeat left top; filter:expression(pngFix(this));}

	@TODO		:
						- G?rer les overflow:auto d?clar?s par d?faut, et  caller automatiquement le layer indiquer cela dans une doc, qu'il faut obligatoirement un ?l?ment conteneur.
						- g?rer les options en les mettant obligatoirement entre guillement, comme ?a on pourra traiter facilement un dictionnaire de parametres type JSON.
						- g?rer les background-position en utilisant le sizingMethod 'image '

*/
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
					if(!url) return;
					elm.src = url[1];
					elm.className = elm.className.replace(/pngFix/g,'');
					alert('done')

				}
				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 (!elmN || elmN.parentNode || !pngLayerN || !pngLayerN.parentNode) return;
								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 : false, // 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 && window.attachEvent && document.all) {
			window.attachEvent('onload', function() {
				setTimeout(pngFixLoader.launch, 100);
			});
		}
	}
}
pngFixLoader.init();