//
//	Librairie by The Rubik's Man
//		    © 2005-2006
//

/*==================================================================================================================/*
/*==================================================================================================================/*
/*===>					--------------------------------------------------------------------------					         <====/*
/*===>					|	   Librairie SlideShow par The Rubik's Man		 |					         <====/*
/*===>					--------------------------------------------------------------------------					         <====/*
/*===>   -- Basee  sur les librairies open source < prototype : moo : moo_fx >								         <====/*
/*===>   -- Fortement inspire par le projet 'mooShow' de EatPixel (http://www.eatpixels.com) dont l'aspect graphique	       	         <====/*
/*===>       a ete en grande partie conserve													                    <====/*
/*===>																			         <====/*
/*===>   -- Tout les bugs resolus, affichage complet et simple des diverses erreurs pouvant survenir					         <====/*
/*===>   -- De nombreuses fonctions ajoutees :    *	Lecture des informations IPTC resolue sur les images en comportant		         <====/*
/*===> 				                   	       *	Mode Diaporama automatique ajoute avec reglage de la vitesse		         <====/*
/*===>					     	       *	SliderBar de vitesse de diaporama ajoute						         <====/*
/*===>  		  			                  *	Option de redimensionnement automatique des images trop grandes		         <====/*
/*===>						       *	Plusieurs SlideslideShows totalement independants sur une meme page html          <====/*
/*===>																			         <====/*
/*===>	-- La mise en place d'un ou plusieurs SlideShow dans une page html est d'une simplicite enfantile			         <====/*
/*===>																			         <====/*
/*===>		  ( Les librairies 'moo effects' , 'prototype' et 'slider' sont protegees par leurs propres licenses )		         <====/*
/*===>							          © The Rubik's Man ©								         <====/*
/*===>																			         <====/*
/*===>	Plan du fichier : 	1)	Librairie allegee et modifiee "prototype"		(ligne 56 -> 240)				         <====/*
/*===>				2)	Librairie legerement modifiee	"moo effects"	(ligne 263 ->537)				         <====/*
/*===>				3)	Librairie legerement modifiee "slider"		(ligne 561 ->1265)				         <====/*
/*===>				4)	Librairie de creation du SlideShow			(ligne 1275-> 2023)			         <====/*
/*===>																			         <====/*
/*==================================================================================================================/*
/*==================================================================================================================/*







//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////   Debut librairie prototype allegee      /////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


/*  Prototype JavaScript framework
 *  (c) 2005 Sam Stephenson <sam@conio.net>
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://prototype.conio.net/
/*--------------------------------------------------------------------------*/

// ###########   Remarque : Version allegee, modifiee et commentee de la librairie prototype  lite ###########  //

// Permet avec la syntaxe " var maClasse = Class.create() " d'instancier une nouvelle classe et d'appeler la methode " initialize() " de cette classe
// la methode " initialize() " est considere comme le constructeur de la classe
var Class = {
				create: function() 
						{
							return function() 
								   {
										this.initialize.apply(this, arguments);
								   }
						}
			}

// Permet d'etendre les proprietes de l'objet 'destination' avec toutes les proprietes de l'objet 'source'
// Attention si les 2 objets ont des noms de proprietes identiques la propriete finale sera celle de l'objet source
Object.extend = function(destination, source) 
				{
					for (property in source) destination[property] = source[property];
					return destination;
				}

// Permet de contrer le moteur javascript dans un bug de reference de fonction
// Generalement utilisee dans les methodes onComplete... onLoad... etc pour faire reference a l'objet en cours
Function.prototype.bind = function(object) 
						  {
							var __method = this;
							return function() 
								   {
										return __method.apply(object, arguments);
								   }
						  }
// Meme principe que la precedente mais s'applique uniquement sur des evenements
Function.prototype.bindAsEventListener = function(object) 
										 {
											var __method = this;
											return function(event) 
												   {
														__method.call(object, event || window.event);
												   }
										 }

// Fonction tres utile permettant de renvoyer une reference de l'element DOM dont l'id est passe en parametre
// On peut aussi passer en parametre un tableau d'id et la fonction renverra un tableau comprenant les references des elements DOM
function $() 
{
	if (arguments.length == 1) return get$(arguments[0]);
	var elements = [];
	$ToArray(arguments).each(
						function(el)
					    {
							elements.push(get$(el));
						}
					   );
	return elements;

	function get$(el)
	{
		if (typeof el == 'string') el = document.getElementById(el);
		return el;
	}
}

// Seulement pour IE : permet d'instancier la variable Element
if (!window.Element) var Element = new Object();


// Etend les proprietes de l'objet ' Element ' avec 5 nouvelles fonctions travaillant sur des elements DOM
Object.extend(
				Element, {
							// Permet de supprimer un element DOM a partir de son id
							remove: function(element) 
									{
										element = $(element);
										if (!element) return;
										element.parentNode.removeChild(element);
									}
									
							,
							
							// Permet de savoir si un element DOM a un nom de classe egal a celui passe en parametre
							hasClassName: function(element, className) 
										  {
												element = $(element);
												if (!element) return;
												var hasClass = false;
												element.className.split(' ').each(
																					function(cn)
																					{
																						if (cn == className) hasClass = true;
																					}
																				  );
												return hasClass;
										  }
										  
							,

							// Permet d'ajouter un nom de classe a un element DOM
							addClassName: function(element, className) 
										  {
												element = $(element);
												Element.removeClassName(element, className);
												element.className += ' ' + className;
										  }
										  
							,

							// Permet de supprimer un nom de classe a un element DOM
							removeClassName: function(element, className) 
											 {
												element = $(element);
												if (!element) return;
												var newClassName = '';
												element.className.split(' ').each(
																					function(cn, i)
																					{
																						if (cn != className)
																						{
																							if (i > 0) newClassName += ' ';
																							newClassName += cn;
																						}
																					}
																				  );
												element.className = newClassName;
											 }
											 
							,

							// Permet d'enlever tous les caracteres blancs dans un element DOM ( espace, retour chariot) entre les balises html
							cleanWhitespace: function(element) 
											 {
												element = $(element);
												$c(element.childNodes).each(
																				function(node)
																				{
																					if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) Element.remove(node);
																				}
																			);
											 }
						}
			 );

// Classe Position
// Est obligatoire pour la librairie moo effects
var Position = {
					cumulativeOffset: function(element) 
									  {
											var valueT = 0, valueL = 0;
											do 
											{
												valueT += element.offsetTop  || 0;
												valueL += element.offsetLeft || 0;
												element = element.offsetParent;
											} 
											while (element);
											return [valueL, valueT];
									  }
				};

// Ajout d'une nouvelle fonction a l'objet DOM 'document'
// Permet de recuperer un tableau d'elements DOM a partir de leur nom de classe
document.getElementsByClassName = function(className) 
								  {
										var children = document.getElementsByTagName('*') || document.all;
										var elements = [];
										$ToArray(children).each(
															function(child)
															{
																if (Element.hasClassName(child, className)) elements.push(child);
															}
														 );  
										return elements;
								  }

// Ajout d'une fonction au type Array
// Permet d'executer une fonction passee en parametre a tous les elements d'un tableau
Array.prototype.each = function(func)
{
	for(var i=0;ob=this[i];i++) func(ob, i);
}

// Fonction personelle 		© The Rubik's Man
// Permet de re-referencer un tableau en type Array
function $ToArray(tab)
{
	var array = [];
	for (i=0;el=tab[i];i++) array.push(el);
	return array;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////  Fin librairie prototype allegee   //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////








//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////// Debut librairie moo  effects    /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
moo.fx, simple effects library built with prototype.js (http://prototype.conio.net).
by Valerio Proietti (http://mad4milk.net) MIT-style LICENSE.
for more info (http://moofx.mad4milk.net).
Sunday, March 05, 2006
v 1.2.3
*/
// Declaration de l'objet contenant toutes les classes de la librairie 'moo effects'
var fx = new Object();
var stepInc = 0;

// Classe de base de tous les effets
fx.Base = function(){};

// Creation du prototype de la classe Base
fx.Base.prototype = {
						// Fonction permettant d'attribuer les options de l'effet instancie
						// On a le choix pour le type de transition : * sinoidal * linear * cubic * circ  ( elles sont decrites plus bas )
						setOptions: function(options) 
									{
										this.options = {
															duration: 500,
															onComplete: '',
															transition: fx.sinoidal
													   }
										Object.extend(this.options, options || {});
									}
									
						,

						// Fonction permettant de faire les transitions d'etat pour l'effet instancie et lance
						step: function() 
							  {
									var time  = (new Date).getTime();
									if (time >= this.options.duration+this.startTime) 
									{
										this.now = this.to;
										clearInterval (this.timer);
										this.timer = null;
										if (this.options.onComplete) setTimeout(this.options.onComplete.bind(this), 10);
									}
									else 
									{
										var Tpos = (time - this.startTime) / (this.options.duration);
										this.now = this.options.transition(Tpos) * (this.to-this.from) + this.from;
									}
									this.increase();
								}
								
						,

						// Fonction permettant de faire la transition de l'etat de depart jusqu'a l'etat d'arrivee
						// C'est la fonction 'step' qui va s'occuper de toutes les etapes intermediaires
						custom: function(from, to) 
								{
									if (this.timer != null) return;
									this.from = from;
									this.to = to;
									this.startTime = (new Date).getTime();
									this.timer = setInterval (this.step.bind(this), 13);
								}
								
						,
						
						// Fonction permettant de mettre a 0 l'effet instancie
						// Fonctionne sur tous les effets ( la fonction 'increase()' met a jour la valeur de l'effet instancie )
						hide: function() 
							  {
								this.now = 0;
								this.increase();
							  }
						
						,

						// Fonction permettant d'arreter la transition de l'effet en cours
						clearTimer: function() 
									{
										clearInterval(this.timer);
										this.timer = null;
									}
					}

// Classe Layout qui permet de travailler sur les dimensions des blocs
fx.Layout = Class.create();

// Creation du prototype de la classe Layout
// La classe Layout herite(logiquement) de la classe Base
fx.Layout.prototype = Object.extend(
										new fx.Base()
										, 
										{
											// Constructeur de la classe Layout
											// Initialise l'element sur lequel va s'appliquer l'effet, ses dimensions et les options
											initialize: function(el, options) 
														{
															this.el = $(el);
															this.el.style.overflow = "hidden";
															this.iniWidth = this.el.offsetWidth;
															this.iniHeight = this.el.offsetHeight;
															this.setOptions(options);
														}
										}
									);

// Classe Height => permet de travailler sur la hauteur d'un element
fx.Height = Class.create();

// La classe Height herite (logiquement) de la classe Layout puis on lui rajoute ses 2 fonctions personnelles
Object.extend(
				Object.extend(fx.Height.prototype, fx.Layout.prototype)
				, 
				{	
					// Fonction permettant de mettre a jour la valeur courante de la hauteur
					increase: function() 
							  {
								this.el.style.height = this.now + "px";
							  }
					,
					// Fonction permettant de faire une transition automatique de hauteur
					// 1er cas : Si la hauteur > 0 => on ramene la hauteur jusqu'a 0
					// 2eme cas : Si la hauteur = 0 => on ramene la hauteur jusqu'a la hauteur initiale ( lors de l'instanciation de l'element dans la classe )
					toggle: function() 
							{
								if (this.el.offsetHeight > 0) this.custom(this.el.offsetHeight, 0);
								else this.custom(0, this.iniHeight);
							}
				}
			  );

// Classe Width => permet de travailler sur la largeur d'un element
fx.Width = Class.create();

// La classe Width herite (logiquement) de la classe Layout puis on lui rajoute ses 2 fonctions personnelles
Object.extend(
				Object.extend(fx.Width.prototype, fx.Layout.prototype)
				, 
				{	
					// Fonction permettant de mettre a jour la valeur courante de la largeur
					increase: function() 
							  {
								this.el.style.width = this.now + "px";
							  }
					,
					// Fonction permettant de faire une transition automatique de largeur
					// 1er cas : Si la largeur > 0 => on ramene la largeur jusqu'a 0
					// 2eme cas : Si la largeur = 0 => on ramene la largeur jusqu'a la largeur initiale ( lors de l'instanciation de l'element dans la classe )
					toggle: function()
							{
								if (this.el.offsetWidth > 0) this.custom(this.el.offsetWidth, 0);
								else this.custom(0, this.iniWidth);
							}
				}
			 );

// Classe Opacity => permet de travailler sur l'intensite d'affichage d'un element
fx.Opacity = Class.create();

// La classe Opacity herite de la classe Base mais n'a pas besoin d'heriter de la classe Layout car elle ne travaille pas sur les dimensions
// On lui rajoute 4 fonctions personnelles
fx.Opacity.prototype = Object.extend(
										new fx.Base()
										, 
										{
											// Constructeur de la classe Opacity
											// Initialise l'element sur lequel va s'appliquer l'effet, initialise l'intensite au maximum et l'applique
											initialize: function(el, options) 
														{
															this.el = $(el);
															this.now = 1;
															this.increase();
															this.setOptions(options);
														}
											,
											// Fonction permettant de mettre a jour la valeur courante de l'intensite
											increase: function() 
													  {
														if (this.now == 1 && (/Firefox/.test(navigator.userAgent))) this.now = 0.9999;
														this.setOpacity(this.now);
													  }
											,
											// Fonction permettant de mettre a jour l'intensite en fonction d'une valeur passee en parametre
											setOpacity: function(opacity) 
														{
															if (opacity == 0 && this.el.style.visibility != "hidden") this.el.style.visibility = "hidden";
															else if (this.el.style.visibility != "visible") this.el.style.visibility = "visible";
															if (window.ActiveXObject) this.el.style.filter = "alpha(opacity=" + opacity*100 + ")";
															this.el.style.opacity = opacity;
														}
											,
											// Fonction permettant de faire des transitions automatiques ( Visible -> Invisible  || Invisible -> Visible )
											toggle: function() 
													{
														if (this.now > 0) this.custom(1, 0);
														else this.custom(0, 1);
													}
										}
									);

// Galerie de transitions  ---->  La plus adaptee au SlideShow est la sinoidal


// Sinusoidale => ralentissant vers la fin ( difficile d'expliquer par une phrase.... )
fx.sinoidal = function(pos)
			  {
				// equation  extraite de http://script.aculo.us
				return ((-Math.cos(pos*Math.PI)/2) + 0.5);
			  }
 
// Lineaire => gardant la meme vitesse a tout moment de la transition ( pas difficile a comprendre )
fx.linear = function(pos)
			{
				return pos;
			}

// Cubique => accelerant tres fortement tout le long de la transition
fx.cubic = function(pos)
		   {
				return Math.pow(pos, 3);
		   }

// Circulaire => tres rapide lors du depart puis ralentissant fortement vers la fin
fx.circ = function(pos)
		  {
			return Math.sqrt(pos);
		  }

// D'autres equations de transitions assez tordues.... ( si vous voulez vous amusez.... ) Allez voir une belle demonstration en flash de ces equations a l'addresse 'http://www.robertpenner.com/easing/easing_demo.html'

//Easing Equations (c) 2003 Robert Penner, all rights reserved.
//This work is subject to the terms in http://www.robertpenner.com/easing_terms_of_use.html.
//expo
fx.expoIn = function(pos)
			{
				return Math.pow(2, 10 * (pos - 1));
			}
fx.expoOut = function(pos)
			 {
				return (-Math.pow(2, -10 * pos) + 1);
			 }

//quad
fx.quadIn = function(pos)
			{
				return Math.pow(pos, 2);
			}
fx.quadOut = function(pos)
			 {
				return -(pos)*(pos-2);
			 }

//circ
fx.circOut = function(pos)
			 {
				return Math.sqrt(1 - Math.pow(pos-1,2));
			 }
fx.circIn = function(pos)
			{
				return -(Math.sqrt(1 - Math.pow(pos, 2)) - 1);
			}

//back
fx.backIn = function(pos)
			{
				return (pos)*pos*((2.7)*pos - 1.7);
			}
fx.backOut = function(pos)
			 {
				return ((pos-1)*(pos-1)*((2.7)*(pos-1) + 1.7) + 1);
			 }

//sine
fx.sineOut = function(pos)
			 {
				return Math.sin(pos * (Math.PI/2));
			 }
fx.sineIn = function(pos)
			{
				return -Math.cos(pos * (Math.PI/2)) + 1;
			}
fx.sineInOut = function(pos)
			  {
				return -(Math.cos(Math.PI*pos) - 1)/2;
			  }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////       Fin librairie moo  effects       /////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////     Debut librairie  speed  Sliderbar       /////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
  *                   			Created by Erik Arvidsson
  *  			       (http://webfx.eae.net/contact.html#erik)
  *          			  For WebFX (http://webfx.eae.net/)
  *   			Copyright (c) 2002, 2005, 2006 Erik Arvidsson 
  *	Licensed under the Apache License, Version 2.0 (the "License"); you may not
  *	 use this file except in compliance with the License.  You may obtain a copy
  *	       of the License at http://www.apache.org/licenses/LICENSE-2.0 
  */

// Classe Range ( compare a un entier borne )

// Constructeur de la classe Range
// Initialise les proprietes de l'objet
function Range() 
{
	this._value = 0;
	this._minimum = 0;
	this._maximum = 100;
	this._extent = 0;
	this._isChanging = false;
}

// Fonction permettant de mettre a jour la valeur de l'entier
Range.prototype.setValue = function (value) 
						   {
								value = Math.round(parseFloat(value));
								if (isNaN(value)) return;
								if (this._value != value) 
								{
									if (value + this._extent > this._maximum) this._value = this._maximum - this._extent;
									else if (value < this._minimum) this._value = this._minimum;
									else this._value = value;
									if (!this._isChanging && typeof this.onchange == "function") this.onchange();
								}
						   };

// Accesseur de la valeur de l'entier
Range.prototype.getValue = function () 
						   {
								return this._value;
						   };

// Fonction permettant de mettre a jour le valeur restrictive
Range.prototype.setExtent = function (extent) 
							{
								if (this._extent != extent) 
								{
									if (extent < 0) this._extent = 0;
									else if (this._value + extent > this._maximum) this._extent = this._maximum - this._value;
									else this._extent = extent;
									if (!this._isChanging && typeof this.onchange == "function") this.onchange();
								}
							};

// Accesseur de la valeur restrictive
Range.prototype.getExtent = function () 
							{
								return this._extent;
							};

// Fonction permettant de mettre a jour la borne inferieure
Range.prototype.setMinimum = function (minimum) 
							 {
								if (this._minimum != minimum) 
								{
									var oldIsChanging = this._isChanging;
									this._isChanging = true;

									this._minimum = minimum;

									if (minimum > this._value) this.setValue(minimum);
									if (minimum > this._maximum) 
									{
										this._extent = 0;
										this.setMaximum(minimum);
										this.setValue(minimum);
									}
									if (minimum + this._extent > this._maximum) this._extent = this._maximum - this._minimum;

									this._isChanging = oldIsChanging;
									if (!this._isChanging && typeof this.onchange == "function") this.onchange();
								}
							 };

// Accesseur a la borne inferieure
Range.prototype.getMinimum = function () 
							 {
								return this._minimum;
							 };

// Fonction permettant de mettre a jour la borne superieure
Range.prototype.setMaximum = function (maximum) 
							 {
								if (this._maximum != maximum) 
								{
									var oldIsChanging = this._isChanging;
									this._isChanging = true;

									this._maximum = maximum;

									if (maximum < this._value) this.setValue(maximum - this._extent);
									if (maximum < this._minimum) 
									{
										this._extent = 0;
										this.setMinimum(maximum);
										this.setValue(this._maximum);
									}
									if (maximum < this._minimum + this._extent) this._extent = this._maximum - this._minimum;
									if (maximum < this._value + this._extent) this._extent = this._maximum - this._value;

									this._isChanging = oldIsChanging;
									if (!this._isChanging && typeof this.onchange == "function") this.onchange();
								}
							 };

// Accesseur a la borne superieure
Range.prototype.getMaximum = function () 
							 {
								return this._maximum;
							 };


// Classe Timer

// Constructeur de la classe Timer
// Initialise les proprietes du timer
function Timer(nPauseTime) 
{
	this._pauseTime = typeof nPauseTime == "undefined" ? 1000 : nPauseTime;
	this._timer = null;
	this._isStarted = false;
}

// Fonction permettant de lancer le timer
Timer.prototype.start = function () 
{
	if (this.isStarted()) this.stop();
	var oThis = this;
	this._timer = window.setTimeout(
										function () 
										{
											if (typeof oThis.ontimer == "function") oThis.ontimer();
										}
										, 
										this._pauseTime
									);
	this._isStarted = false;
};

// Fonction permettant d'arreter le timer
Timer.prototype.stop = function () 
{
	if (this._timer != null) window.clearTimeout(this._timer);
	this._isStarted = false;
};

// Fonction permettant de savoir si le timer est demarre
Timer.prototype.isStarted = function () 
{
	return this._isStarted;
};

// Accesseur a la valeur du temps de pause
Timer.prototype.getPauseTime = function () 
{
	return this._pauseTime;
};

// Fonction permettant de modifier la valeur du temps de pause
Timer.prototype.setPauseTime = function (nPauseTime) 
{
	this._pauseTime = nPauseTime;
};




// Classe Slider ( permettant de creer le slider )

// Verifie que le navigateur peut afficher correctement le slider
Slider.isSupported = typeof document.createElement != "undefined" 
				&&
					typeof document.documentElement != "undefined" 
				&&
					typeof document.documentElement.offsetWidth == "number";

// Constructeur du Slider
// 		oElement : 		id du formulaire contenant l'input du slider
//		oInput :     		id de l'input du slider
//		orientation :	orientation (horizontal | vertical)  defaut => horizontal
function Slider(oElement, oInput, sOrientation) 
{
	if (!oElement) return;
	this._orientation = sOrientation || "horizontal";
	this._range = new Range();
	this._range.setExtent(0);
	this._blockIncrement = 10;
	this._unitIncrement = 1;
	this._timer = new Timer(100);

	// Si le formulaire a ete trouve et que le navigateur supporte correctement l'affichage
	if (Slider.isSupported && oElement) 
	{
		this.document = oElement.ownerDocument || oElement.document;
		this.element = oElement;
		this.element.slider = this;
		this.element.unselectable = "on";
	
		// Affectation du nom de classe en fonction de l'orientation ( permet le bon affichage grace a la feuille de style CSS )
		this.element.className = this._orientation + " " + this.classNameTag + " " + this.element.className;
	
		// Creation de la ligne du slider
		this.line = this.document.createElement("DIV");
		this.line.className = "line";
		this.line.unselectable = "on";
		this.line.appendChild(this.document.createElement("DIV"));
		this.element.appendChild(this.line);
	
		// Creation du bouton de control
		this.handle = this.document.createElement("DIV");
		this.handle.className = "handle";
		this.handle.unselectable = "on";
		this.handle.appendChild(this.document.createElement("DIV"));
		this.handle.firstChild.appendChild(this.document.createTextNode(String.fromCharCode(160)));
		this.element.appendChild(this.handle);
	}
	// Enregistrement de l'element DOM de l'input
	this.input = oInput;

	// Partie du code ou on va intercepter et gerer tous les evenements
	var oThis = this;
	
	// Fonction executee lorsque la fonction Range.setValue() est executee
	// Repositionne le curseur au bon endroit sur la ligne et lance la fonction Slider.onchange()
	this._range.onchange = function () 
	{
		oThis.recalculate();
		if (typeof oThis.onchange == "function") oThis.onchange();
	};

	if (Slider.isSupported && oElement) 
	{
		this.element.onfocus		= Slider.eventHandlers.onfocus;
		this.element.onblur			= Slider.eventHandlers.onblur;
		this.element.onmousedown	= Slider.eventHandlers.onmousedown;
		this.element.onmouseover	= Slider.eventHandlers.onmouseover;
		this.element.onmouseout		= Slider.eventHandlers.onmouseout;
		this.element.onkeydown		= Slider.eventHandlers.onkeydown;
		this.element.onkeypress		= Slider.eventHandlers.onkeypress;
		this.element.onmousewheel	= Slider.eventHandlers.onmousewheel;
		this.handle.onselectstart	=
		this.element.onselectstart	= function () { return false; };
	
		this._timer.ontimer = function () 
		{
			oThis.ontimer();
		};
		// Pour IE
		window.setTimeout(
							function() 
							{
								oThis.recalculate();
							}
							,
							1
						 );
	}
	else 
	{
		this.input.onchange = function (e) 
							  {
									oThis.setValue(oThis.input.value);
							  };
	}
}

// Enregistrement de toutes les actions a faire lors des evenements
Slider.eventHandlers = {

							// Fonction permettant de simplifier la recuperation des evenements en fonction des navigateurs
							getEvent:	function (e, el) 
										{
											if (!e) 
											{
												if (el)	e = el.document.parentWindow.event;
												else e = window.event;
											}
											if (!e.srcElement) 
											{
												var el = e.target;
												while (el != null && el.nodeType != 1)
												el = el.parentNode;
												e.srcElement = el;
											}
											if (typeof e.offsetX == "undefined") 
											{
												e.offsetX = e.layerX;
												e.offsetY = e.layerY;
											}
											return e;
										}
							,
							// Fonction permettant de recuperer le document DOM complet
							getDocument:	function (e) 
											{
												if (e.target) return e.target.ownerDocument;
												return e.srcElement.document;
											}
							,
							// Fonction permettant de recuperer l'element DOM representant le slider
							getSlider:	function (e) 
										{
											var el = e.target || e.srcElement;
											while (el != null && el.slider == null)	
											{
												el = el.parentNode;
											}
											if (el) return el.slider;
											return null;
										}
							,
							// Fonction permettant de recuperer l'element DOM representant la ligne du slider
							getLine:	function (e) 
										{
											var el = e.target || e.srcElement;
											while (el != null && el.className != "line")
											{
												el = el.parentNode;
											}
											return el;
										}
							,
							// Fonction permettant de recuperer l'element DOM representant le curseur du slider
							getHandle:	function (e) 
										{
											var el = e.target || e.srcElement;
											var re = /handle/;
											while (el != null && !re.test(el.className))
											{
												el = el.parentNode;
											}
											return el;
										}
							,
							
							// Fonction executee lors du focus du slider
							onfocus:	function (e) 
										{
											var s = this.slider;
											s._focused = true;
											s.handle.className = "handle hover";
										}
							,
							// Fonction executee lors du blur du slider
							onblur:	function (e) 
									{
										var s = this.slider
										s._focused = false;
										s.handle.className = "handle";
									}
							,
							// Fonction executee lorsque la souris passe au dessus du slider
							onmouseover:	function (e) 
											{
												e = Slider.eventHandlers.getEvent(e, this);
												var s = this.slider;
												if (e.srcElement == s.handle) s.handle.className = "handle hover";
											}
							,
							// Fonction executee lorsque la souris sort du slider
							onmouseout:	function (e) 
										{
											e = Slider.eventHandlers.getEvent(e, this);
											var s = this.slider;
											if (e.srcElement == s.handle && !s._focused) s.handle.className = "handle";
										}
							,
							// Fonction executee lorsque le bouton de la souris est presse
							onmousedown:	function (e) 
											{
												e = Slider.eventHandlers.getEvent(e, this);
												var s = this.slider;
												if (s.element.focus) s.element.focus();
												
												Slider._currentInstance = s;
												var doc = s.document;

												if (doc.addEventListener) 
												{
													doc.addEventListener("mousemove", Slider.eventHandlers.onmousemove, true);
													doc.addEventListener("mouseup", Slider.eventHandlers.onmouseup, true);
												}
												else if (doc.attachEvent) 
												{
													doc.attachEvent("onmousemove", Slider.eventHandlers.onmousemove);
													doc.attachEvent("onmouseup", Slider.eventHandlers.onmouseup);
													doc.attachEvent("onlosecapture", Slider.eventHandlers.onmouseup);
													s.element.setCapture();
												}
												
												if (Slider.eventHandlers.getHandle(e)) 
												{	// Le curseur commence a se deplacer
													Slider._sliderDragData = {
																				screenX:	e.screenX,
																				screenY:	e.screenY,
																				dx:			e.screenX - s.handle.offsetLeft,
																				dy:			e.screenY - s.handle.offsetTop,
																				startValue:	s.getValue(),
																				slider:		s
																			 };
												}
												else 
												{
													var lineEl = Slider.eventHandlers.getLine(e);
													s._mouseX = e.offsetX + (lineEl ? s.line.offsetLeft : 0);
													s._mouseY = e.offsetY + (lineEl ? s.line.offsetTop : 0);
													s._increasing = null;
													s.ontimer();
												}
											}
							,
							// Fonction executee lorsque la souris bouge
							onmousemove:	function (e) 
											{
												e = Slider.eventHandlers.getEvent(e, this);

												if (Slider._sliderDragData) 
												{
													// Le curseur est deplace
													var s = Slider._sliderDragData.slider;

													var boundSize = s.getMaximum() - s.getMinimum();
													var size, pos, reset;

													if (s._orientation == "horizontal") 
													{
														size = s.element.offsetWidth - s.handle.offsetWidth;
														pos = e.screenX - Slider._sliderDragData.dx;
														reset = Math.abs(e.screenY - Slider._sliderDragData.screenY) > 100;
													}
													else 
													{
														size = s.element.offsetHeight - s.handle.offsetHeight;
														pos = s.element.offsetHeight - s.handle.offsetHeight - (e.screenY - Slider._sliderDragData.dy);
														reset = Math.abs(e.screenX - Slider._sliderDragData.screenX) > 100;
													}
													s.setValue(reset ? Slider._sliderDragData.startValue :
																s.getMinimum() + boundSize * pos / size);
													return false;
												}
												else 
												{
													var s = Slider._currentInstance;
													if (s != null) 
													{
														var lineEl = Slider.eventHandlers.getLine(e);
														s._mouseX = e.offsetX + (lineEl ? s.line.offsetLeft : 0);
														s._mouseY = e.offsetY + (lineEl ? s.line.offsetTop : 0);
													}
												}

											},
							// Fonction executee lorsque le bouton de la souris est relache
							onmouseup:	function (e) 
										{
											e = Slider.eventHandlers.getEvent(e, this);
											var s = Slider._currentInstance;
											var doc = s.document;
											if (doc.removeEventListener) 
											{
												doc.removeEventListener("mousemove", Slider.eventHandlers.onmousemove, true);
												doc.removeEventListener("mouseup", Slider.eventHandlers.onmouseup, true);
											}
											else if (doc.detachEvent) 
											{
												doc.detachEvent("onmousemove", Slider.eventHandlers.onmousemove);
												doc.detachEvent("onmouseup", Slider.eventHandlers.onmouseup);
												doc.detachEvent("onlosecapture", Slider.eventHandlers.onmouseup);
												s.element.releaseCapture();
											}

											if (Slider._sliderDragData) 
											{
												// Le curseur est relache
												Slider._sliderDragData = null;
											}
											else 
											{
												s._timer.stop();
												s._increasing = null;
											}
											Slider._currentInstance = null;
										}
							,
							// Fonction executee lorsqu'une touche est pressee
							onkeydown:	function (e) 
										{
											e = Slider.eventHandlers.getEvent(e, this);
											var s = this.slider;
											var kc = e.keyCode;
											switch (kc) 
											{
												case 33:	// haut de page
													s.setValue(s.getValue() + s.getBlockIncrement());
													break;
												case 34:	// bas de page
													s.setValue(s.getValue() - s.getBlockIncrement());
													break;
												case 35:	// fin
													s.setValue(
																s.getOrientation() == "horizontal" ?
																							s.getMaximum() 
																					:
																							s.getMinimum()
															  );
													break;
												case 36:	// debut
													s.setValue(
																s.getOrientation() == "horizontal" ?
																							s.getMinimum() 
																					:
																							s.getMaximum()
															  );
													break;
												case 38:	// haut
												case 39:	// droite
													s.setValue(s.getValue() + s.getUnitIncrement());
													break;
												case 37:	// gauche
												case 40:	// bas
													s.setValue(s.getValue() - s.getUnitIncrement());
													break;
											}
											if (kc >= 33 && kc <= 40) return false;
										}
							,
							// Fonction executee lorsqu'une touche est relachee ( equivalent a onkeyup)
							onkeypress:	function (e) 
										{
											e = Slider.eventHandlers.getEvent(e, this);
											var kc = e.keyCode;
											if (kc >= 33 && kc <= 40) return false;
										}
							,
							// Fonction executee lorsque la roulette de la souris est en action
							onmousewheel:	function (e) 
											{
												e = Slider.eventHandlers.getEvent(e, this);
												var s = this.slider;
												if (s._focused) 
												{
													s.setValue(s.getValue() + e.wheelDelta / 120 * s.getUnitIncrement());
													return false;
												}
											}
						};

// Nom de la classe dans la feuille de style CSS
Slider.prototype.classNameTag = "dynamic-slider-control";

// Fonction permettant de mettre a jour la valeur courante du slider ( en fait appelle les fonction de la classe Range et de l'input
Slider.prototype.setValue = function (v) 
							{
								this._range.setValue(v);
								this.input.value = this.getValue();
							};

// Accesseur a la valeur courante du slider ( egale a la valeur courante de l'objet Range )
Slider.prototype.getValue = function () 
							{
								return this._range.getValue();
							};

// Modificateur du minimum du slider ( minimum de l'objet Range associe )
Slider.prototype.setMinimum = function (v) 
							  {
								this._range.setMinimum(v);
								this.input.value = this.getValue();
							  };

// Accesseur a la valeur courante du minimum du slider ( egale a la valeur courante du minimum de l'objet Range )
Slider.prototype.getMinimum = function () 
							  {
								return this._range.getMinimum();
							  };

// Modificateur du maximum du slider ( maximum de l'objet Range associe )
Slider.prototype.setMaximum = function (v) 
						  	  {
								this._range.setMaximum(v);
								this.input.value = this.getValue();
							  };

// Accesseur a la valeur courante du maximum du slider ( egale a la valeur courante du maximum de l'objet Range )
Slider.prototype.getMaximum = function () 
							  {
								return this._range.getMaximum();
							  };

// Modificateur de l'unite d'incrementation du slider
Slider.prototype.setUnitIncrement = function (v) 
									{
										this._unitIncrement = v;
									};

// Accesseur a la valeur courante du l'unite d'incrementation du slider
Slider.prototype.getUnitIncrement = function () 
									{
										return this._unitIncrement;
									};

// Modificateur du nombre d'unite d'incrementation par bloc d'incrementation
Slider.prototype.setBlockIncrement = function (v) 
									 {
										this._blockIncrement = v;
									 };

// Accesseur a la valeur courante du nombre d'incrementation lors d'un changement par bloc du slider ( lorsque la  touche haut de page est pressee par exemple )
Slider.prototype.getBlockIncrement = function () 
									 {
										return this._blockIncrement;
									 };

// Accesseur a l'orientation courante du slider
Slider.prototype.getOrientation = function () 
								  {
									return this._orientation;
								  };

// Modificateur de l'orientation courante du slider
Slider.prototype.setOrientation = function (sOrientation) 
{
	if (sOrientation != this._orientation) 
	{
		if (Slider.isSupported && this.element) 
		{
			// Change le nom de classe pour les nouvelles valeurs de style des differents blocs du slider
			this.element.className = this.element.className.replace(this._orientation,sOrientation);
		}
		this._orientation = sOrientation;
		this.recalculate();

	}
};

// Fonction permettant de recalculer les dispositions des elements du slider en fonction des valeurs courantes
// C'est cette fonction qui deplace la div du curseur (image du curseur)
Slider.prototype.recalculate = function() 
{
	if (!Slider.isSupported || !this.element) return;

	var w = this.element.offsetWidth;
	var h = this.element.offsetHeight;
	var hw = this.handle.offsetWidth;
	var hh = this.handle.offsetHeight;
	var lw = this.line.offsetWidth;
	var lh = this.line.offsetHeight;

	if (this._orientation == "horizontal") 
	{
		this.handle.style.left = (w - hw) * (this.getValue() - this.getMinimum()) / (this.getMaximum() - this.getMinimum()) + "px";
		this.handle.style.top = (h - hh) / 2 + "px";

		this.line.style.top = (h - lh) / 2 + "px";
		this.line.style.left = hw / 2 + "px";
		this.line.style.width = Math.max(0, w - hw - 2)+ "px";
		this.line.firstChild.style.width = Math.max(0, w - hw - 4)+ "px";
	}
	else 
	{
		this.handle.style.left = (w - hw) / 2 + "px";
		this.handle.style.top = h - hh - (h - hh) * (this.getValue() - this.getMinimum()) / (this.getMaximum() - this.getMinimum()) + "px";

		this.line.style.left = (w - lw) / 2 + "px";
		this.line.style.top = hh / 2 + "px";
		this.line.style.height = Math.max(0, h - hh - 2) + "px";
		this.line.firstChild.style.height = Math.max(0, h - hh - 4) + "px";
	}
};

// Fonction permettant de verifier lorsque le bouton de la souris est presse sur le curseur si celui ci est deplace
// Fait donc varier la valeur courante du slider ( valeur de l'objet Range associe) en fonction du nombre de pixels deplaces
Slider.prototype.ontimer = function () 
{
	var hw = this.handle.offsetWidth;
	var hh = this.handle.offsetHeight;
	var hl = this.handle.offsetLeft;
	var ht = this.handle.offsetTop;

	if (this._orientation == "horizontal") 
	{
		if (this._mouseX > hl + hw && (this._increasing == null || this._increasing)) 
		{
			this.setValue(this.getValue() + this.getBlockIncrement());
			this._increasing = true;
		}
		else if (this._mouseX < hl && (this._increasing == null || !this._increasing))
		{
			this.setValue(this.getValue() - this.getBlockIncrement());
			this._increasing = false;
		}
	}
	else 
	{
		if (this._mouseY > ht + hh && (this._increasing == null || !this._increasing)) 
		{
			this.setValue(this.getValue() - this.getBlockIncrement());
			this._increasing = false;
		}
		else if (this._mouseY < ht && (this._increasing == null || this._increasing)) 
		{
			this.setValue(this.getValue() + this.getBlockIncrement());
			this._increasing = true;
		}
	}

	this._timer.start();
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////        Fin librairie  speed  Sliderbar         /////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////   Debut librairie principale SlideShow      /////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*  				SlideShow javascript creation
 *	  Copyright (c) 2006 Peter BUGAN ( alias The Rubik's Man)  <ocbslim@tiscali.fr>
 *	  		Free but protected by the Apache License 2.0
 *	  You can find the license file in the folder " slider/licenses "
*/

// Declaration du tableau qui contiendra tous les objets de type SlideShow
var slideShowTab = new Object();

// Fonction permettant d'initialiser l'affichage du ou des SlideShows sur la page
// Cette fonction doit etre executee au chargement de la page
function init_SlideShows() 
{
	// Recuperation des blocs div des slideshows grace a leur nom de classe
	slideShows = document.getElementsByClassName("SlideShow");
	
	// Erreur si aucune div de classe 'SlideShow' n'est trouvee
	// Et erreur si vous avez IE 5.5 et que la variable hacking
	if (slideShows.length == 0 && typeof (slideShowsIE) == 'undefined')
	{
		alert('Erreur : Aucun SlideShow definis dans le code HTML');
		return;
	}
	// Si vous aves IE 5.5 et que la variable hacking
	else if ( typeof (slideShowsIE) != 'undefined' ) slideShows = slideShowsIE;
	
	// Creation de tous les SlideShows trouves
	for ( var i = 0; i < slideShows.length; i++ ) 
	{
		// Recuperation du nom du SlideShow courant
		slideShowName = slideShows[i].id;
		// Uniquement pour IE 5.5 => recuperation du nom du slideshow dans le variable hacking
		if(slideShowName==null) slideShowName = slideShowsIE[i];
		
		// Si la galerie de photo pour ce slideshow est definie
		if ( typeof(eval(slideShowName)) == 'object' && typeof(eval(slideShowName).id) == 'undefined')
		{
			// Creation de l'objet SlideShow
			slideShowTab[ slideShowName ] = new SlideShow(slideShowName);
			// Generation du code HTML pour l'affichage sur la page
			create_HTML(slideShowName);
		}
		// Si le slideshow est definie mais que sa galerie est introuvable
		//else alert('Erreur : Le SlideShow \''+slideShowName+'\' est defini mais aucune galerie n\'est definie pour ce SlideShow');
	}
}

// Fonction permettant de redimensionner automatiquement une image en fonction des dimensions et des options
function autoResize(photoSize)
{	
	// Fonction permettant de redimensionner une photo en fonction de la resolution actuelle de l'ecran
	// Utile si jamais la photo a une grande qualite => l'affichage se fera sans scrolling
	function imageResizeToScreen(photoSize)
	{
		width_diff = screen.width - photoSize[0];
		height_diff = screen.height - photoSize[1];
		smaller_diff = width_diff < height_diff ? 'width' : 'height';
		must_be_resize = eval(smaller_diff+'_diff') < 200 ? true : false;									
			
		if ( !must_be_resize ) return photoSize;
		
		if ( eval(smaller_diff+'_diff') == 'width' )
		{
			width = screen.width - 200;
			height = parseInt((width/photoSize[0])*photoSize[1]);
		}
		else
		{
			height = screen.height - 200;
			width = parseInt((height/photoSize[1])*photoSize[0]);
		}
		return [width, height];
	 }
	
	// Fonction permettant de redimensionner les images dont la largeur est inferieure a 250px
	// Permet d'afficher tous les elements du slideshow correctement
	function imageMinimumResize(photoSize)
	{
		if ( photoSize[0] >= 200 ) return photoSize;
		
		width = 200;
		height = parseInt((width/photoSize[0])*photoSize[1]);
		
		return [width, height];
	}
	
	// Choix de la fonction qui correspond a l'image actuelle
	goodResizeFunction = photoSize[0] < 250 ? 
									imageMinimumResize
								:
									( 
										this.autoResizeToScreen == 'yes' ? 
																imageResizeToScreen 
															:
																function()
																{
																	return arguments[0];
																}
									);
	// Puis on applique la fonction avec les dimensions de l'image courante
	return goodResizeFunction(photoSize);
}

// Fonction permettant de generer le code html de chaques slideshows trouves
function create_HTML( slideShowName ) 
{
	// Recuperation des options de configuration du slideshow definies dans le bloc div dans la page html ( ex: this.speed=300;this.fadeSpeed=400; ....)
	eval($(slideShowName).innerHTML);
	
	// Recuperation du tableau des images pour ce slideshow
	photo_galery = eval(slideShowName);
	
	// Redimensionnement de la premiere image
	firstImageSizeArray = autoResize([photo_galery[0][1],photo_galery[0][2]]); 
	// valeurs mediane et maximale sur l'echelle du slider
	maxSliderVal = Math.round((this.maxAutoPlayDelay/1000)*10)/10;
	medSliderVal = Math.round((maxSliderVal/2)*10)/10;
	
	// Sil l'option bordure onmbree est activee alors on ajoute le nom de la classe ShadowStyle
	if(this.ShadowStyle == 'yes') this.divClass = 'SlideShow_divExt ShadowStyle';
	else this.divClass = 'SlideShow_divExt';
	
	// Va permettre de fixer le bug du cache de IE pour la reactualisation des images
	// exemple : au lieu de <img src="xxx.bmp">  =>  <img src="xxx.bmp?249537..."> avec le nombre qui n'est jamais le meme. Cela permet a IE de toujours reactualiser ses sources
	// Tres utile si on change d'orientation une image apres l'avoir deja faite passe dans le slideshow
	// Sinon elle ne sera jamais affichee correctement sous IE meme en vidant le cache... on est oblige de renomer le fichier
	// =======> Fix simple et tres pratique   pour avoir le nombre : en javascript : date = new Date(); puis date.getTime();
	date = new Date();
	
	// Code HTML que l'on va inserer dans la div correspondante
	var slideShow_html_code = ''+
	'<div id=\''+slideShowName+'_divExt\' class=\''+this.divClass+'\' style=\'padding:'+this.border+'px;\'> \n'+
	'	<div id=\''+slideShowName+'_topNav\' style=\'width:'+firstImageSizeArray[0]+'px;\' class=\'SlideShow_topNav\'></div> \n'+
	'	<div id=\''+slideShowName+'_divInt\' class=\'SlideShow_divInt\' > \n'+
	'		<img src=\''+photo_galery[0][0]+'?'+date.getTime()+'\' class=\'SlideShow_image\' width=\''+firstImageSizeArray[0]+'\' height=\''+firstImageSizeArray[1]+'\' id=\''+slideShowName+'_image\' /> \n'+
	'		<img src=\'./SlideShow_module/css/images/loading.gif?'+date.getTime()+'\' id=\''+slideShowName+'_loading\' class=\'SlideShow_loading\' /> \n'+
	'		<div id=\''+slideShowName+'_ImageNav\' class=\'SlideShow_ImageNav\' style=\'height:'+firstImageSizeArray[1]+'px; width:'+firstImageSizeArray[0]+'px;\'> \n'+
	'			<a href=# id=\''+slideShowName+'_prevLink\' class=\'SlideShow_prevImg\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].prevImage();return false;\' ></a> \n'+
	'			<a href=# id=\''+slideShowName+'_nextLink\' class=\'SlideShow_nextImg\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].nextImage();return false;\' ></a> \n'+
	'		</div> \n'+
	'		<div id=\''+slideShowName+'_IPTC\' class=\'SlideShow_IPTC\' style=\'width:'+firstImageSizeArray[0]+'px;\'></div> \n'+
	'		<a href=#><img src=\'./SlideShow_module/css/images/info.gif?'+date.getTime()+'\' alt=\"Image Informations\" id=\''+slideShowName+'_IPTCbutton\' class=\'SlideShow_IPTCbutton\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].updateIPTCinfoToggle();return false;\' /></a> \n'+
	'		<form id="'+slideShowName+'SliderBar" onsubmit="return false;"style="_position: absolute;_top: 0;_width: 75px;_right: 50px;" class="slider_pos">\n'+
	'			<div id="'+slideShowName+'sliderBar" tabIndex="1" style="width: 90px;_width: 75px; margin: 10px;">\n'+
	'				<input name="'+slideShowName+'_slider_bar_input" class="slider-input" id="'+slideShowName+'_slider_bar_input"/>\n'+
	'				<div id="'+slideShowName+'min_slider_val" class="minSliderValue">0s</div>\n'+
	'				<div id="'+slideShowName+'med_slider_val" class="medSliderValue">'+medSliderVal+'s</div>\n'+
	'				<div id="'+slideShowName+'max_slider_val" class="maxSliderValue">'+maxSliderVal+'s</div>\n'+
	'			</div>\n'+
	'		</form>\n'+
	'		<a href=#><img src=\'./SlideShow_module/css/images/play_active.gif?'+date.getTime()+'\' alt=\"Play SlideShow \''+slideShowName+'\'\" id=\''+slideShowName+'_PLAYbutton\' class=\'SlideShow_PLAYbutton\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].autoPlay();return false;\' /></a> \n'+
	'		<a href=#><img src=\'./SlideShow_module/css/images/stop.gif?'+date.getTime()+'\' alt=\"Stop SlideShow \''+slideShowName+'\'\" id=\''+slideShowName+'_STOPbutton\' class=\'SlideShow_STOPbutton\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].stopAutoPlay();return false;\' /></a> \n'+
	'	</div> \n'+
	'	<div id=\''+slideShowName+'_bottom\' class=\'SlideShow_bottom\'> \n'+
	'		<div id=\''+slideShowName+'_descriptions\' class=\'SlideShow_descriptions\' style=\'padding-top:'+this.border+'px;padding-left:-'+this.border+'px; width:'+firstImageSizeArray[0]+'px;\'><center><u>Description :</u> " '+photo_galery[0][7]+'&nbsp;"</center></div> \n'+
	'	</div> \n'+
	'</div> \n'+
	'<script></script>';
	// On envoit le code dans l'element DOM
	Element.setInnerHTML(slideShowName, slideShow_html_code);
	
	// On ajoute les messages affiches lors du survol des differents elements
	Element.setStatusBar(slideShowName+'_nextLink',"Image Suivante");
	Element.setStatusBar(slideShowName+'_prevLink',"Image Precedente");
	Element.setStatusBar(slideShowName+'_IPTCbutton',"Informations sur l'image");
	Element.setStatusBar(slideShowName+'_PLAYbutton',"Jouer le diaporama");
	Element.setStatusBar(slideShowName+'_STOPbutton',"Arreter le diaporama");
	
	// Creation du slider pour le reglage de la vitesse de transition du diaporama
	slider_bar_input = slideShowName+'_slider_bar_input';
	var sliderEl = document.getElementById ? document.getElementById(slideShowName+"sliderBar") : null;
	eval('var inputEl = document.getElementById(\''+slider_bar_input+'\');');
	
	// On stocke le slider auquel on ajoute 3 proprietes dans la propriete 'speedSlider' du slideshow courant
	slideShowTab[slideShowName].speedSlider = Object.extend
							(
								new Slider(sliderEl, inputEl)
								,
								{
									// Nom du slideshow auquel est ratache le slider
									SlideShowName : slideShowName
									,
									// Reference  du slideshow ( afin de simplifier l'acces a ses proprietes dans la fonction onchange => on peut utiliser this.SlideShow au lieu de slideShowTab[this.SlideShowName].....)
									SlideShow : slideShowTab[slideShowName]
									,
									// Fonction executee a chaque deplacement du slider permettant de mettre a jour la valeur de temps de transition du slideshow
									onchange : function () 
											   {
													newDelay = parseInt(((this.getValue())/100)*this.SlideShow.maxAutoPlayDelay);
													this.SlideShow.currentAutoPlayDelay = newDelay;
											   }
								}
							);
	// Ligne de code affreuse... desole mais obligatoire si on veut que le curseur du slider soit a la bonne position lors du chargement du slideshow
	// Par defaut le temps de transition au chargement est regle a la moitie du temps maximum autorise ==> ( this.maxAutoPlayDelay/2 )
	// Donc si on change la valeur par defaut le slider grace a cette ligne de code affreuse sera deplace au bon endroit automatiquement
	slideShowTab[slideShowName].speedSlider.setValue(parseInt((slideShowTab[slideShowName].currentAutoPlayDelay/slideShowTab[slideShowName].maxAutoPlayDelay)*100));
	// Fin de creation du slider de transition
	
	
	// Masquage des differentes parties du SlideShow en fonction des options definies dans la page html
	// Bloc de navigation superieur ( liste des numeros des images pour aller a l'image que l'on veut
	if(this.topNav == 'no') Element.hide(slideShowName+'_topNav');
	else slideShowTab[slideShowName].updateTopNav(slideShowName);
	
	// Navigation Image suivante et Image precedente
	if(this.ImageNav == 'no') Element.hide(slideShowName+'_ImageNav');
	// Bloc inferieur description de l'image courante
	if(this.descriptions == 'no') Element.hide(slideShowName+'_descriptions');
	// Bouton permettant d'afficher les informations de l'image
	if(this.IPTCinfo == 'no') Element.hide(slideShowName+'_IPTCbutton');
	// Bloc permettant la navigation automatique ( mode diaporama ) => ( bouton play | bouton stop | slider de reglage )
	if (this.SlideShowControls == 'no' )
	{
		Element.hide(slideShowName+'SliderBar');
		Element.hide(slideShowName+'_PLAYbutton');
		Element.hide(slideShowName+'_STOPbutton');
	}
	
	// Puis on afficher le slideshow ( cette fonction change simplement la propriete style 'display:none;' vers 'display:inline;' )
	Element.show(slideShowName);
}





// Classe SlideShow gerant entierement tout le slideshow
var SlideShow = Class.create();
SlideShow.prototype = {
	// Constucteur de la classe SlideShow
	initialize: function(slideShowName) 
				{
					this.id = slideShowName; // Nom du slideshow
					this.busy = 0;
					this.loaded = 1; // Permet de fixer le bug de IE avec les images GIF animees qui lance le reload a chaque redemarrage de l'animation
					this.counter = 0;
					this.photo_galery = eval(this.id); // Tableau des images pour ce slideshow
					this.numberOfImages = this.photo_galery.length -2; // -2 car un tableau commence a 0 et a la fin on met une image vide pour detecter la fin
					this.IPTCinfoStatus = 0;
					this.autoPlayTimeOutId = setTimeout('slideShowTab[\''+this.id+'\'].nextImage()',this.currentAutoPlayDelay);
					
					eval($(slideShowName).innerHTML); // On recupere toutes les options definies dans la page html
					this.currentAutoPlayDelay = parseInt(this.maxAutoPlayDelay/2); // Valeur par defaut du temps de transition
				}
	,
	// Fonction permettant d'activer le mode diaporama automatique avec le temps de transition courant
	autoPlay: function()
			  {
				if ( this.autoPlayTimeOutId == 0 )
				{
					date = new Date();
					document.getElementById(this.id+'_PLAYbutton').src = './SlideShow_module/css/images/play_active.gif?'+date.getTime();
					this.autoPlayTimeOutId = setTimeout('slideShowTab[\''+this.id+'\'].nextImage()',this.currentAutoPlayDelay);
				}	
			  }
	,
	// Fonction permettant d'arreter le mode diaporama automatique
	stopAutoPlay: function()
				  {
						date = new Date();
						document.getElementById(this.id+'_PLAYbutton').src = './SlideShow_module/css/images/play.gif?'+date.getTime();
						clearTimeout(this.autoPlayTimeOutId);
						this.autoPlayTimeOutId = 0;
				  }
	,
	// Fonction permettant d'afficher l'image suivante
	nextImage: function() 
			   {
					if(this.busy<1)
					{
						this.busy=1;
						this.loaded=0;
						if(this.counter < this.numberOfImages) 
						{
							this.counter ++;
						} 
						else 
						{
							this.counter = 0;
						}
						this.loadImage();
					}
			   }
	,
	// Fonction permettant d'afficher l'image precedente
	prevImage: function() 
			   {
					if(this.busy<1)
					{
						this.busy=1;
						this.loaded=0;
						if(this.counter > 0) 
						{
							this.counter --;
						} 
						else 
						{
							this.counter = this.numberOfImages;
						}
						this.loadImage();			
					}
			   }
	,
	// Fonction permettant d'afficher nimporte quelle image grace au bloc de navigation superieur
	jumptoImage: function(counter) 
				 {
					if(this.busy<1)
					{
						this.busy=1;
						this.loaded=0;
						this.counter = counter-1;
						this.loadImage();		
					}
				 }
	,
	// Fonction permettant de changer de galerie dans le meme slideshow
	switchGalery: function(newArray) 
				   {
						if(this.busy<1)
						{
							this.busy=1;
							this.loaded=0;
							this.photo_galery = eval(newArray);
							this.numberOfImages = this.photo_galery.length -2;
							this.counter = 0;
							this.loadImage();		
						}
				   }
	,
	// Fonction permettant de mettre a jour le bloc d'information de l'image courante
	updateIPTCinfo: function() 
					{
							//get slideShowName
							slideShowName = this.id;
							// 
							this.iptcHTML = ''+
							'<div class=\'SlideShow_IPTC_left\'><br/><br/>'+
							'	Image URL <br/>'+
							'	Size <br/>'+
							'	Dimensions <br/>'+
							'	Title <br/>'+
							'	Author <br/>'+
							'	Copyright <br/><br/>'+
							'	Description <br/><br/>'+
							'</div>'+
							'<div class=\'SlideShow_IPTC_right\'><br/><br/>'+
							'	<a href=\''+this.photo_galery[this.counter][0]+'\'>'+this.photo_galery[this.counter][0]+'</a><br/>'+ // url de l'image
							'	'+this.photo_galery[this.counter][3]+'<br/>'+ // taille de l'image
							'	'+this.photo_galery[this.counter][1]+' x '+this.photo_galery[this.counter][2]+' pixels<br/>'+ // dimensions de l'image
							'	'+this.photo_galery[this.counter][4]+'<br/>'+ // titre de l'image
							'	'+this.photo_galery[this.counter][5]+'<br/>'+ // auteur de l'image
							'	'+this.photo_galery[this.counter][6]+'<br/><br/>'+ // copyright de l'image
							'	'+this.photo_galery[this.counter][7]+'<br/><br/>'+ // description de l'image
							'</div>';

							Element.setInnerHTML(''+slideShowName+'_IPTC', this.iptcHTML);
					}
	,
	// Fonction permettant d'afficher ou de cacher le bloc d'information
	updateIPTCinfoToggle: function() 
						  {
								slideShowName = this.id;
								date = new Date();
								if(this.IPTCinfoStatus==1)
								{
									document.getElementById(this.id+'_IPTCbutton').src = './SlideShow_module/css/images/info.gif?'+date.getTime();
									Element.hide(''+slideShowName+'_IPTC');
									this.IPTCinfoStatus=0;
								} 
								else 
								{
									document.getElementById(this.id+'_IPTCbutton').src = './SlideShow_module/css/images/info_active.gif?'+date.getTime();
									Element.show(''+slideShowName+'_IPTC');
									this.IPTCinfoStatus=1;
									this.updateIPTCinfo();
								}
						  }
	,
	// Fonction permettant de mettre a jour le bloc de navigation superieur ( numero pour l'image courante et liens pour les autres images
	updateTopNav: function(slideShowName) 
				  {
						// To fix the IE cache bug
						date = new Date();
						Element.setInnerHTML(slideShowName+'_topNav', '');
						this.topNavContent = $(slideShowName+'_topNav').innerHTML;
						
						this.topNavContent = (this.counter+1) + ' / ' + (this.photo_galery.length-1) + ' <img src=\'./SlideShow_module/css/images/blank.gif?'+date.getTime()+'\' width=\'10\' height=\'1\' />';
						
						for ( var i = 1; i < this.photo_galery.length; i++ ) 
						{
							
							if(i==this.counter+1)
							{
								this.topNavContent = this.topNavContent + i;
							} 
							else 
							{
								this.topNavContent = this.topNavContent + ' <a href=\'#'+i+'\' onClick=\'slideShowTab[&#39;'+slideShowName+'&#39;].jumptoImage('+i+');return false;\'>'+i+'</a>';
							}
							if(i<this.photo_galery.length-1)
							{
								this.topNavContent = this.topNavContent + ' | ';
							}
						}
						
						document.getElementById(slideShowName+'_topNav').innerHTML = this.topNavContent;
				  }
	,
	
	// Fonction principale gerant toute les transitions entre images => redimensionnement | intensite | prechargement etc...
	loadImage: function() 
	{
		// Recuperation du nom du slidewhow courant
		slideShowName = this.id;
		busy = this.busy;
		// On met a jour le bloc de navigation superieur
		if(this.topNav=='yes')this.updateTopNav(slideShowName);
		// On affiche l'image du loading ( dans le coin gauche )
		Element.show(slideShowName+'_loading');
		// On cache les blocs d'informations de l'image et aussi l'image du bouton permettant l'affichage de ces informations
		Element.hide(slideShowName+'_IPTC');
		Element.hide(slideShowName+'_IPTCbutton');
		
		// On cache les boutons de navigation Image suivante et Image precedente
		if(this.ImageNav == 'yes') Element.hide(slideShowName+'_ImageNav');
		
		
		// On instancie un nouvel objet image qui va servir au prechargement
		newImgPreloader = new Image();
		
		// On definie la fonction qui sera executee lorsque le prechargement sera termine
		newImgPreloader.onload=function()
		{
			// Pour IE si l'image a deja ete chargee on annule ( probleme trouve que sous IE , firefox ok )
			if ( slideShowTab[slideShowName].loaded == 1 ) return;
			slideShowTab[slideShowName].loaded = 1;
			
			// Avant les transitions on masque l'image avec l'image vide
			date = new Date();
			Element.setSrc(slideShowName+'_image','./SlideShow_module/css/images/blank.gif?'+date.getTime());
			Element.setOpacity(slideShowName+'_image',0);
			
			// Le bloc de descriptions est mis a zero
			Element.setInnerHTML(slideShowName+'_descriptions', '&nbsp;');
			
			// On recupere les dimensions de l'image redimensionnees ou pa selon la taille de l'image et de l'option
			newSize = autoResize([newImgPreloader.width,newImgPreloader.height]);
			newHeight = newSize[1];
			newWidth = newSize[0];	
			
			// Redimensionnement avec transition de la largeur du bloc de navigation superieur
			this.resizeTopNavWidth = new fx.Width(
														slideShowName+'_topNav'
														,
														{
															// Option duration : duree de la transition definie dans la page html ( this.speed)
															duration: slideShowTab[slideShowName].speed
														}
												  );
			
			// Redimensionnement avec transition de la largeur du bloc d'informations inferieur
			this.resizeDescriptionWidth = new fx.Width(
														slideShowName+'_descriptions'
														,
														{
															// Option duration : duree de la transition definie dans la page html ( this.speed)
															duration: slideShowTab[slideShowName].speed
														}
												  );
			
			// Redimensionnement avec transition de la hauteur du bloc div contenant l'image
			this.resizeDivImageHeight = new fx.Height(
																slideShowName+'_image'
																,
																{
																	// Option duration : duree de la transition definie dans la page html ( this.speed)
																	duration: slideShowTab[slideShowName].speed
																}
															);
			
			// Redimensionnement avec transition de la largeur du bloc div contenant l'image
			this.resizeDivImageWidth = new fx.Width(
															slideShowName+'_image'
															, 
															{
																// Option duration : duree de la transition definie dans la page html ( this.speed)
																duration: slideShowTab[slideShowName].speed
																,
																// On rajoute l'option onComplete ici pour lancer le fader et effectuer les actions lors de la fin des transitions de dimensionnement
																// On peut mettre cette option dans nimporte lequel des redimensionnement puisque tous les redimensionnement se termineront en meme temps
																// Pour raison d'ecrtiture je l'ai mis dans le dernier...
																onComplete: function() 
																			{
																				// Changement de l'url de l'image vide avec l'url de la nouvelle image
																				Element.setSrc(slideShowName+'_image',newImgPreloader.src);
																				
																				// Mise a jour des dimensions et positionnement des blocs de navigation ImageSuivant et ImagePrecedente
																				Element.setHeight(slideShowName+'_ImageNav',newHeight);
																				Element.setWidth(slideShowName+'_ImageNav',newWidth);
																				
																				// On afficher le bloc de description inferieur si l'option est activee
																				if(slideShowTab[slideShowName].descriptions == 'yes') Element.setInnerHTML(slideShowName+'_descriptions', '<center><u>Description :</u> " '+slideShowTab[slideShowName].photo_galery[slideShowTab[slideShowName].counter][7] + '&nbsp;"</center>');
																				
																				// Creation de l'objet gerant le fader de l'image
																				this.fader = new fx.Opacity(
																												slideShowName+'_image'
																												, 
																												{
																													// Option duration : duree de la transition definie dans la page html ( this.fadeSpeed)
																													duration: slideShowTab[slideShowName].fadeSpeed
																													,
																													
																													// Lorsque la transition d'intensite est terminee
																													onComplete:function() 
																															   {
																																	// On cache l'image de loading ( petit sablier dans le coin gauche )
																																	Element.hide(slideShowName+'_loading');
																																	
																																	// Le slideshow est maintenant au repos, toutes les transitions sont terminees
																																	slideShowTab[slideShowName].busy = 0;
																																	
																																	// Affichage en fonction de l'option du bloc de navigation ImageSuivant ImagePrecedente
																																	if(slideShowTab[slideShowName].ImageNav == 'yes') Element.show(slideShowName+'_ImageNav');
																																	
																																	// Affichage en fonction de l'option du bouton d'affichage des informations
																																	if(slideShowTab[slideShowName].IPTCinfo == 'yes') Element.show(slideShowName+'_IPTCbutton');
																																	Element.setWidth(slideShowName+'_IPTC', newWidth);
																																	
																																	// Si le bloc d'information etait active avant les transitions alors on le reaffiche
																																	if(slideShowTab[slideShowName].IPTCinfoStatus==1)
																																	{
																																		slideShowTab[slideShowName].IPTCinfoStatus=0; 
																																		slideShowTab[slideShowName].updateIPTCinfoToggle();
																																	}
																																	
																																	// Si le mode autoplay est active alors on relance le timer
																																	if ( slideShowTab[slideShowName].autoPlayTimeOutId != 0 ) slideShowTab[slideShowName].autoPlayTimeOutId = setTimeout('slideShowTab[\''+slideShowName+'\'].nextImage()',slideShowTab[slideShowName].currentAutoPlayDelay);
																																}
																												}
																											);
																				this.fader.hide(); // On met a 0 l'intensite de l'image
																				this.fader.toggle(); // Puis on lance la transition de l'intensite de 0 a 1
																			}
															}
														 );
			// Enregistrement des dimensions de l'image avant les transitions
			oldHeight = Element.getHeight(slideShowName+'_image');
			oldWidth = Element.getWidth(slideShowName+'_image');


			///////////////////////////////////////////////////////////////////////
			//		 		Lancement de toutes les transitions				//
			///////////////////////////////////////////////////////////////////////
			this.resizeTopNavWidth.custom(oldWidth,newWidth);
			this.resizeDescriptionWidth.custom(oldWidth,newWidth);
			this.resizeDivImageHeight.custom(oldHeight,newHeight);
			this.resizeDivImageWidth.custom(oldWidth,newWidth);
			///////////////////////////////////////////////////////////////////////
		};
				
		// Enregistrement de l'url de la nouvelle image a charger
		date = new Date();
		newImgPreloader.src = this.photo_galery[this.counter][0]+'?'+date.getTime();
	}
}









// Extension de l'objet Element avec des fonctions souvent utilisees
Object.extend(
				Element
				, 
				{
					// Permet d'obtenir la largeur d'un element
					getWidth: function(element) 
							  {
									if ( typeof(element) == 'undefined' ) return;
								   	element = $(element);
								   	return element.offsetWidth; 
							  }
					,
					
					// Permet d'obtenir la hauteur d'un element
					getHeight: function(element) 
							   {
									if ( typeof(element) == 'undefined' ) return;
								   	element = $(element);
								   	return element.offsetHeight; 
							   }
					,
					
					// Permet de fixer la largeur d'un element
					setWidth: function(element,w) 
							  {
									if ( typeof(element) == 'undefined' || typeof(w) == 'undefined' ) return;
								   	element = $(element);
							    	element.style.width = w +"px";
							  }
					,
					
					// Permet de fixer la hauteur d'un element
					setHeight: function(element,h) 
							   {
									if ( typeof(element) == 'undefined' || typeof(h) == 'undefined' ) return;
							   		element = $(element);
							    	element.style.height = h +"px";
							   }
					,
					
					// Permet de fixer la position en hauteur d'un element
					setTop: function(element,t) 
							{
									if ( typeof(element) == 'undefined' || typeof(t) == 'undefined' ) return;
								   	element = $(element);
							    	element.style.top = t +"px";
							}
					,
					
					// Permet de fixer la source url d'un element
					setSrc: function(element,src) 
							{
									if ( typeof(element) == 'undefined' || typeof(src) != 'string' ) return;
							    	element = $(element);
							    	element.src = src;
							}
					,
					
					// Permet de fixer la propriete ALT d'un element
					setAlt: function(element,alt) 
							{
									if ( typeof(element) == 'undefined' || typeof(alt) != 'string' ) return;
							    	element = $(element);
							    	element.alt = alt; 
							}
					,
					
					// Permet de fixer l'intensite d'affichage d'un element
					setOpacity: function(element,opacity) 
								{
									if ( typeof(element) == 'undefined' || typeof(opacity) == 'undefined' ) return;
							    	element = $(element);
							    	element.style.opacity = opacity; 
								}
					,
					
					// Permet de fixer le lien HREF d'un element
					setHref: function(element,href) 
							 {
									if ( typeof(element) == 'undefined' || typeof(href) != 'string' ) return;
							    	element = $(element);
							    	element.href = href; 
							 }
					,
					
					// Permet de fixer le code html d'un element
					setInnerHTML: function(element,content) 
								  {
									if ( typeof(element) == 'undefined' || typeof(content) != 'string' ) return;
									element = $(element);
									element.innerHTML = content;
								  }
					,
					
					// Permet de cacher un element
					hide: function(element) 
						  {
									if ( typeof(element) == 'undefined' ) return;
							      	element = $(element);
							      	element.style.display = 'none';
					  	  }
					,
					
					// Permet d'afficher un element
				  	show: function(element) 
						  {
									if ( typeof(element) == 'undefined' ) return;
							      	element = $(element);
							      	element.style.display = 'inline';
					  	  }
					,
					
					// Permet au survol d'un element d'afficher un message dans la barre de statut
					setStatusBar: function(element,string)
								  {
									if ( typeof(element) == 'undefined' || typeof(string) != 'string' ) return;
									string = string.replace(/'/gi,'\'');
									element = $(element);
									element.onmouseover = function(event)
														  {
															window.status = string;
															return true;
														  }
									element.onmouseout = function(event)
														 {
															window.status = '';
															return true;
														 }
								  }
				}
			 );


// Fonction perso permettant d'attribuer une chaine de caractere a la barre de statut
function setStatus(string)
{
	if ( typeof(string) == 'undefined' )
	{
		window.status = '';
		return;
	}
	if ( typeof(string) != 'string' ) return;
	window.status = string
}

// Fonction perso permettant de mettre les elements onMouseOver et onMouseOut automatiquement dans un element DOM
function statusbar(string)
{
	string = typeof(string) == 'undefined' || typeof(string) != 'string' ? '' : string;
	return ' onMouseOver="window.status=\''+string.replace(/\'/gi,'\\\'')+'\';return true;" onMouseOut="window.status=\'\';return true;" ';
}

// Fonction permettant d'ajouter une fonction au chargement de la page sans effacer les fonctions precedemment definies
function addLoadEvent(func)
{	
	if ( typeof(func) != 'function' ) return;
	var oldonload = window.onload;
	if (typeof (window.onload) != 'function') window.onload = func;
	else 
	{
		window.onload = function()
						{
							oldonload();
							func();
						}
	}
}

// On enregistre la fonction d'iniaitalisation des slideshows au chargement de la page
addLoadEvent(init_SlideShows);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////   Fin librairie principale SlideShow       /////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//
//	Librairie by The Rubik's Man
//		    © 2005-2006
//