/************

*  Fichier Javascript commun

*

*

*****************/



/**************

* Variables globales 

**************/

var IS_IE = document.all && window.print && !window.opera && /MSIE [56]/.test(navigator.userAgent);

var IE_W3C = document.all && window.print && !window.opera && /MSIE [789]/.test(navigator.userAgent);

var IS_Webkit = /Konqueror|Safari|KHTML/.test(navigator.userAgent);

var heightPropertyToUse = IS_IE ? "height" : "minHeight";



document.documentElement.className += " hasJS";



/********************

* Framework

* Ensemble de fonctions qui aident au developpement

* Certaines de ces fonctions ne sont pas documentees, par le simple fait qu'ellesfonctionnent parfaitement et n'ont pas a  etre modifiees.

*******************/



/* AddEvent :

	Cette fonction permet d'associer une fonction a un evenement,

	ex : addEvent(window, "load", mafonction)

	ne Jamais mettre de parentheses a la fonction passee en parametres

*/

function addEvent( obj, type, fn )

{

	if (obj.addEventListener)

		obj.addEventListener( type, fn, false );

	else if (obj.attachEvent)

	{

		obj["e"+type+fn] = fn;

		obj[type+fn] = function() { obj["e"+type+fn]( window.event ); }

		obj.attachEvent( "on"+type, obj[type+fn] );

	}

}



/* supprime la propagation du click sur un element (le click n'est pas repercute sur les autres elements en dessous du block en question) */

function cancelClick(e){

	if (window.event){

		window.event.cancelBubble = true;

		return;

	}

	if (e){

		if (e.stopPropagation) {

			e.stopPropagation();

		}

	}

}

/*  getStyle : 

	Cette fonction permet de recuperer le style declare sur un element, meme si celui-ci a ete declare dans la feuille de style.

	ex : getStyle(monelement, "padding-top");

*/

function getStyle(oElm, strCssRule){

	var strValue = "";

	if(document.defaultView && document.defaultView.getComputedStyle) {

		try{ strValue = document.defaultView.getComputedStyle(oElm, "").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;

}



/*  intStyle : 

	Cette fonction retourne une valeur entiere d'un style.

	ex : 

		getStyle(monelement, "padding-top"); // retourne 15px, mais on ne veut que 15

		intStyle(monelement, "padding-top"); // retourne 15

		

*/

function intStyle(oElm, strCSSRule) {

	var val = parseInt(getStyle(oElm, strCSSRule));

	if (isNaN(val)) val=0;

	return val;

}



/*  floatStyle : 

	Cette fonction retourne la  valeur flottante d'un style.

	ex : 

		getStyle(monelement, "width"); // retourne 15.5em, mais on ne veut que 15.5

		floatStyle(monelement, "padding-top"); // retourne 15

	Cette fonction n'est pas encore utilisee, mais peut-etre dans un developpement futur.	

*/

function floatStyle(oElm, strCSSRule) {

	var val = parseFloat(getStyle(oElm, strCSSRule));

	if (isNaN(val)) val=0;

	return val;

}



/* findPos : 

	recupere la position X,Y d'un objet dans une page

	ex : 

		var pos = findPos(elm);



*/

function findPos(obj) {

	var curleft = curtop = 0;

	if (obj.offsetParent) {

		curleft = obj.offsetLeft

		curtop = obj.offsetTop

		while (obj = obj.offsetParent) {

			curleft += obj.offsetLeft

			curtop += obj.offsetTop

		}

	}

	return [curleft,curtop];

}





/* getMouse : 

	Recupere les coordonnees de la souris et les met dans les variables globales 

		window.mouseX

	et	window.mouseY, 

		il faut passer event en parametre sur les evenements

	ex : 

		function fun(param1, param2, e) {

			getMouse(e);

			sourisX = window.mouseX;

			sourisY = window.mouseY

		}

		fun("foo", "bar", event);



*/

/* getMouse :  */

function getMouse(e){

	var x,y; var elt = (navigator.userAgent.indexOf("MSIE 5")!=-1) ? document.body : document.documentElement;

	if ( document.captureEvents ) {

		x = e.pageX;

		y = e.pageY;

	} else if ( window.event.clientX ) {

		x = window.event.clientX+elt.scrollLeft;

		y = window.event.clientY+elt.scrollTop;

	}

	window.mouseX = x;

	window.mouseY = y;

}



/* generateElements();

	genere des coins sur les blocks contenant la classe "corners" 

	Cette fonction n'est plus utilisee par simple choix de la fnac.

	Je laisse cette fonction mais commentee afin que d'autres puissent s'inspirer si besoin.

*/

function generateElements() {

	var content = document.body;

	var div = content.getElementsByTagName("div");

	

	//corners 

	var tl = document.createElement("span"); tl.className="tl";

	var tr = document.createElement("span"); tr.className="tr";

	var bl = document.createElement("span"); bl.className="bl";

	var br = document.createElement("span"); br.className="br";

	//outsidecorners

	var outsideTl = tl.cloneNode(true);

	var outsideTr = outsideTl.appendChild(tr.cloneNode(true));

	var outsideBl = bl.cloneNode(true);

	var outsideBr = outsideBl.appendChild(br.cloneNode(true));

	//borders

	var sl = document.createElement("span"); sl.className="sl";

	var sr = document.createElement("span"); sr.className="sr";

	var st = document.createElement("span"); st.className="st";

	var sb = document.createElement("span"); sb.className="sb";

	

	function addCorners(elm) {

		with (elm) {

			appendChild(tl.cloneNode(true));appendChild(tr.cloneNode(true));

			appendChild(bl.cloneNode(true));appendChild(br.cloneNode(true));

		}

	}

	function addTopCorners(elm) {

		with (elm) {

			appendChild(tl.cloneNode(true));appendChild(tr.cloneNode(true));

		}

	}

	function addCornersChangingClass(elm, tlclass, trclass, blclass, brclass) {

		with (elm) {

			appendChild(tl.cloneNode(true)).className=tlclass;

			appendChild(tr.cloneNode(true)).className=trclass;

			appendChild(bl.cloneNode(true)).className=blclass;

			appendChild(br.cloneNode(true)).className=brclass;

		}

	}

	function addOutsideCorners(elm) {

		with (elm) {

			insertBefore(outsideTl.cloneNode(true), firstChild);

			appendChild(outsideBl.cloneNode(true));

		}

	}

	function addSides(elm){

		with(elm){

			appendChild(sl.cloneNode(true));appendChild(sr.cloneNode(true));

			appendChild(st.cloneNode(true));appendChild(sb.cloneNode(true));

		}

	}

	

	function addSidesChangingClass(elm, slclass, srclass, stclass, sbclass) {

		with(elm){

			appendChild(sl.cloneNode(true)).className=slclass;

			appendChild(sr.cloneNode(true)).className=srclass;

			appendChild(st.cloneNode(true)).className=stclass;

			appendChild(sb.cloneNode(true)).className=sbclass;

		}

	}

	

	for (var i=div.length-1; i>=0; i--) {

		var x=div[i];

		if (!x.alreadyProcessed) {

			if (x.className.match(/\bcorners\b/)){

				addCorners(x);

			}

			else if (x.className.indexOf("blockTransparentOutside")!=-1) {

				addOutsideCorners(getDivInside(x));

			}

			else if (x.className.indexOf("navigation")!=-1) {

				addCorners(getDivInside(x));

			} 

			else if (x.id=="mainInside") {

				addCornersChangingClass(x, "colTl", "colTr", "colBl", "colBr");

			}

			

			if (x.className.match(/\bsides\b/)){

				addSides(x);

			}

			x.alreadyProcessed=true;

		}



	}

}





function getDivInside(elm, className) {

	className = className ? className : "blockInside";

	var re = new RegExp("\\b" + className + "\\b");

	var divs = elm.getElementsByTagName("div");

	for (var i=0; i<divs.length; i++) {

		var div = divs[i];

		if (div.className.match(re))

			return div

	}

}







/*  addHover : 

	Cette fonction ajoute le fonctionnement de la pseudo classe hover en CSS, et seulement pour IE

	Elle se base sur les evenement propres a  IE qui sont les evenements qui ont le comportement le plus proche du :hover en CSS.

	Pour utiliser cette fonction il faut le faire en CSS

	ex : 

		#menu ul li {behavior:expression(addHover(this))}

		Afin de ne pas prendre en compte IE7 en mode strict il suffit de placer la classe .IS_IE avant, cette classe est ajoutee pendant le chargement de la page.

		.IS_IE #menu ul li {behavior:expression(addHover(this))}

*/

function addHover(elm) {

	elm.style.behavior = " ";

	elm.onmouseenter = function() {

		this.className+= ' hover';

	}

	elm.onmouseleave = function() {

		this.className = this.className.replace(/\bhover\b/,"");

	}

}









/*************

* Fonctions pour fixer les coins sous IE

* Une fonctions est prevue aussi pour Safari 2.0, Opera 8.5 et FF 1.0 pour certains cas

**************/

var CSSBottomCorners=[]; //array pouvant contenir les coins absolu positionnes en bottom

var currentBlockToFixCorners=null; //variable globale utilisee lorsqu'on veux fixer les coins sur un seul bloc



/*  cssRight : 

	fixe les coins positionnes en absolu a  droite

	ex : 

		body.IS_IE .tr {right:expression(addHover(this))}

		Il faut afin que cela fonctionne, avoir declare le right dans un selecteur precedent (pour les autres navigateurs).

		ex : .tr {height:5px;  width:5px; right:0}

		Afin de ne pas prendre en compte IE7 en mode strict il suffit de placer la classe .IS_IE avant, cette classe est ajoutee pendant le chargement de la page et n'est ajoutee que pour IE5.x ou 6.

*/

function cssRight(elm) {

	if (elm.currentStyle.right=="auto") elm.style.right = "auto";

	else elm.style.right=(parseInt(elm.currentStyle.right)-(elm.parentNode.offsetWidth%2))+"px";

}



/*  cssBottom :  (comme CSS right avec un parametre supplementaire)

	fixe les coins positionnes en absolu a  droite

	ex : 

		body.IS_IE .br {bottom:expression(addHover(this))}

	Il faut afin que cela fonctionne, avoir declare le right dans un selecteur precedent (pour les autres navigateurs).

	Afin de ne pas prendre en compte IE7 en mode strict il suffit de placer la classe .IS_IE avant, cette classe est ajoutee pendant le chargement de la page et n'est ajoutee que pour IE5.x ou 6.

	

	Si on veut rajouter ces coins dans un array qui permettra de les refixer si le bloc s'agrandit ou autre. il suffit de rajouter "true" dans les parametres.

	ex : 

		body.IS_IE .br {bottom:expression(addHover(this, true))}

*/

function cssBottom(elm, pushElement) {

	if (pushElement && !elm.CSSBottomAlreadyCSS) {

		CSSBottomCorners.push(elm);

		elm.CSSBottomAlreadyCSS=true;

	}

	if (elm.currentStyle.bottom=="auto") elm.style.bottom = "auto";

	else elm.style.bottom=(parseInt(elm.currentStyle.bottom)-(elm.parentNode.offsetHeight%2))+"px";

}



/*  fixCorners : 

	Cette fonction  est appelee lorsque l'on doit fixer tous les coins d'une page ou d'un block.

	ex : 

		fixCorners ();  //Lance la fonction pour fixer tous les blocks, il faut lancer la fonction une fois la page chargee.

		fixCorners(block); //en passant un element en parametre, le traitement ne se fera que sur le bloc et non sur toute la page.

*/

function fixCorners(block) {

	if (IS_IE) {

		for (i=CSSBottomCorners.length-1; i>-1; --i) {

			CSSBottomCorners[i].style.bottom="";

		}

	} else {

		if (IS_Webkit || /Gecko\/200[56]|Opera 8.5/i.test(navigator.userAgent)) fixCornersOnBlocks(block);

	}

}



/* 

	fixCornersOnBlocks : 

	Ajoute une classe CSS hidecorners afin de cacher les coins puis les reafficher.

	Cette fonction n'est lancee que pour Safari, Le moteur Gecko 2005 (FF1.0) et Opera 8.5), car lorsqu'on agrandit un block en Javascript, les coins en absolu positionnes en bas restent a  leur place. Cette fonction corrige le probleme.

*/

function fixCornersOnBlocks(block) {

	currentBlockToFixCorners = block || document.body;

	currentBlockToFixCorners.className+=" hidecorners";

	setTimeout("fixCornersOnBlocksShowCorners()",5);

}



/* 

	fixCornersOnBlocksShowCorners : 

	Fonction associee a  fixCornersOnBlocks(), cette fonction retire la classe hidecorners qui a ete appliquee a  currentBlockToFixCorners

*/

function fixCornersOnBlocksShowCorners() {

	if (currentBlockToFixCorners) currentBlockToFixCorners.className=currentBlockToFixCorners.className.replace(/\bhidecorners\b/g,"");

	currentBlockToFixCorners=null;

}





/*

	fixBorders

*/

function fixBorders(){

	var content = document.body;

	var div = content.getElementsByTagName("div");

	

	for (var i=div.length-1; i>=0; i--) {

		var x=div[i];

		if (x.className.match(/\bsides\b/)){

			x.style.clear='both';

			var bs = x.getElementsByTagName('span');

			var taille=[0,0];

			for (var j=0;j<bs.length;j++){

				var bsj = bs[j];

				if (bsj.className.match(/\btl\b/)){

					taille[0] = bsj.offsetHeight;

					taille[1] = bsj.offsetWidth;

				}else if (bsj.className.match(/\b(sl|sr)\b/)){

					bsj.style.height = (x.offsetHeight-(2*taille[0])+1)+"px";

					bsj.style.top = taille[0]+"px";

				}else if (bs[j].className.match(/\b(st|sb)\b/)){

					bsj.style.width = (x.offsetWidth-(2*taille[1])+1)+"px";

					bsj.style.left = taille[1]+"px";

				}

			}

			x.style.clear='none';

		}

	}

}



/*

	cssButton

*/

function cssButton(elm){

	var width = Math.round(elm.offsetWidth*75/100);

	elm.style.width = ((width%2)==0)?width+"px":(width+1)+"px";

}



/*

	fixButton

*/

function fixButton(){

	if (IS_IE) {

		var bts = document.getElementsByTagName('BUTTON');

		for (var i=0;i<bts.length;i++){

			var o = bts[i];

			if (o.style.width){

				o.style.width='';

				cssButton(o);

			}else{

				cssButton(o);

			}

		}

	}

}



/*****************

* domLoad et onload fonctions

* Ces fonctions permettent de lancer des fonctions en 2 temps

* - Soit pendant le chargement de la page (mais le DOM est construit)

* - Soit une fois que la page est construite

*****************/

/* variables globales (arrays et booleens) qui permettent de gerer le lancement des fonctions domload et onload */

var domLoaded=false;

var domMustLaunch=false;

var domLoadFunctionLaunched=false;

var domLoadTimer=null;

var domLoadArrFunctions=[];

var onloadArrFunctions=[];



/* 

	domLoad() : 

	Appartient a un ensemble de fonctions qui sont lancees pendant le chargement de la page, une fois le DOM construit

	Cette fonction attend que le dom soit totalement construit

*/

function domLoad() {

	if(document.getElementById("footer")) {

		domLoadCaller();

	} else {

		domLoadTimer=setTimeout("domLoad()",10);

	}

}

domLoad();



/* 

	domLoadCaller() : 

	Appartient a un ensemble de fonctions qui sont lancees pendant le chargement de la page, une fois le DOM construit

	Cette fonction gere le lancement de la fonction finale domLoadFunctions();

	domLoadCaller() lances les fonctions contenues dans un array de fonctions et gere le fait que domLoad doit etre lance avant le onload

*/

function domLoadCaller() {

	domLoadFunctionLaunched=true;

	for (var i=0; i<domLoadArrFunctions.length; i++) {

		domLoadArrFunctions[i]();

	}

	domLoadFunctions();

	domLoaded=true;

	if(domMustLaunch) {

		onloadCaller();

	}

}



/* 

	onloadCaller() : // ne pas modifier cette fonction

	Cette fonction gere le lancement de la fonction finale onLoadFunctions();

	onLoadCaller() est executee une fois que la page est chargee. 

*/

function onloadCaller() {

	clearTimeout(domLoadTimer);

	if (!domLoadFunctionLaunched) {

		domLoadCaller();

	}

	if (!domLoaded) {

		domMustLaunch=true;

		return;

	}

	for (var i=0; i<onloadArrFunctions.length; i++) {

		onloadArrFunctions[i]();

	}

	onloadFunctions();

}



/* 

	addDomLoadFunc() : 

	permet d'ajouter facilement une fonction qui sera lancee avant avant le chargement complet de la page. 

	ex : 

		function myfunc() {

			//contenu fonction.

		}	

		addDomLoadFunc(myfunc) // il ne faut pas mettre les parentheses, car ici on passe une fonction en parametres.

		

	Si on veut lancer la fonction avec des parametres, il faut passer par une fonction anonyme.

	ex : 	

		function myfunc(p1, p2) {

			//contenu fonction.

		}	

		addDomLoadFunc(

			function () {

				myfunc("foo", "bar");

			}

		);

		// il ne faut pas mettre les parentheses, car ici on passe une fonction en parametres.

*/

function addDomLoadFunc(f) {

	domLoadArrFunctions.push(f);

}

/* 

	addOnLoadFunc() : 

	permet d'ajouter facilement une fonction qui sera lancee une fois la page chargee.

	fonctionne de la meme maniere que addDomLoadFunc()

*/

function addOnloadFunc(f) {

	onloadArrFunctions.push(f);

}



//on lance la fonction onloadCaller une fois la page chargee.

addEvent(window, "load", onloadCaller);



/***** fin domLoad et onload fonctions *****/





/***************

* Executions des fonctions au chargement de la page

 ***************/

/* 

	domLoadFunctions() :

	cette fonction est lancee pendant le chargement de la page, une fois que le DOM est completement construit 

*/

function domLoadFunctions() {

	document.body.className+=" hasJS"; //cette classe rajoute une classe CSS qui permet des actions afin de cacher ou afficher des elements seulement pour les visiteurs qui ont le Javascript active sur leur navigateur. (exemple le hidesubmit)

	if (IS_IE) document.body.className+=" IS_IE"; //cette classe permet d'utiliser des hacks CSS/JS seulement pour IE6 et versions inferieures.

	generateElements();

	init();

}



/*

	onloadFunctions() :

	cette fonction est lancee une fois que la page est totalement chargee (images, flash, fichiers associes)

*/

function onloadFunctions() {

	fixCorners(); //correction des coins (seulement pour IE et si besoin pour anciennes version des autres navigateurs)

	fixButton();

	fixBorders();

}



/***************

* fonction specifique au site

 ***************/

 

 function fontSize(size){

	var body = document.getElementsByTagName('body')[0];

	body.className = body.className.match(/\b(normal|medium|large)\b/)?body.className.replace(/(normal|medium|large)/,size):body.className+' '+size;

	fixButton();

	fixBorders();

	return false;

 }

 

 function showHide(showId){

	var elm=document.getElementById(showId);

	if (elm){

		var parent = elm.parentNode;

		var uls = parent.getElementsByTagName('UL');

		for (var i=0;i<uls.length;i++){

			var o = uls[i];

			o.className = o.className.indexOf('shown')!=-1?o.className.replace(/\bshown\b/,''):o.className;

		}

		elm.className += ' shown';

	}

 }



 function init(){

	showHide('troisieme');

	showHide('deuxieme');

	showHide('premier');

    

    // ACN : Mise a jour

    showHide('actualite_par_defaut');

 }

 

 //GDA DI 75518 affichage d'un bloc par idToDisplay via une checkbox netuiTagName

 function displayBlockByCheckboxTagName(netuiTagName,idToDisplay)

 {

  displayBlockByCheckBox2(document.getElementById(netuiTagName),idToDisplay);

 }



 //GDA DI 75518 affichage d'un bloc par idToDisplay via une checkbox checkBox

 function displayBlockByCheckBox2(checkBox,idToDisplay)

 {

  var td = document.getElementById(idToDisplay);

  

  if(checkBox.checked)

    td.style.display='';

  else

    td.style.display='none';

 }

 

  //GDA DI 75518 affichage d'un bloc par idToDisplay via une checkbox checkBox

 function displayBlockByCheckBox(checkBox,idToDisplay)

 {

  var td = document.getElementById(idToDisplay);

  

  if(checkBox.checked)

    td.style.display='';

  else

    td.style.display='none';

  onloadFunctions();

 }

 

 // MPI 196  

function demarrage() { // lancement des fonctions au chargement de la page

	bulle_job("id_tooltip1");

	bulle_job("id_tooltip2");

	bulle_job("id_tooltip3");

	bulle_job("id_tooltip4");

	bulle_job("id_tooltip5");

	bulle_job("id_tooltip6");

	bulle_job("id_tooltip7");

	bulle_job("id_tooltip8");

    bulle_job("id_tooltip9");

    bulle_job("id_tooltip10");

}



//vérification utilisation DOM des navigateurs

if (document.getElementById && document.createTextNode) {

	addOnloadFunc(demarrage);

}



//MPI 196

function bulle_job(id) {

	if (document.getElementById(id)) { // vérifie la présence de id_tooltips

		var vid = document.getElementById(id);

		if (vid) {

			var vtitle = vid.getAttribute('title');// récupère le contenu de

													// title de l'élément id

			vid.onmouseover = function() {

				Tip('<div class=\'GCtooltipsCEL\'>' + vtitle + '</div>')

			}; // survol de la souris -> tooltips avec le contenu de title

			vid.onmouseout = function() {

				UnTip()

			};

		}

	}

}