/**
 * Change l'url de 'ajouter au panier' dans la mini-fiche lorsqu'une taille est choisie
 * @param url nouvelle url d'ajout au panier
 * @param id identifiant du produit configurable
 * @return
 */
function changerLienAjoutPanier(select,id) {
    $('bouton-ajout-panier-'+id).setAttribute('href',select.value);
}

/*
 * Fonction permettant de retourner en pixel la hauteur
 * visible d'un élément par rapport à la fenêtre du navigateur
 * @return integer h (hauteur en pixel)
 */
function getVisibleHeight(elt) {
    var elt_h = elt.getHeight();
    var elt_offset = elt.cumulativeOffset();
    var viewport_h = document.viewport.getHeight();
    var viewport_offset = document.viewport.getScrollOffsets();
    var h_min_visible = viewport_offset.top;
    var h_max_visible = viewport_offset.top + viewport_h;
    var h = elt_h;
    /* Depasse en haut de la zone visible */
    if (elt_offset.top < viewport_offset.top)
        h -= viewport_offset.top - elt_offset.top;
    /* Depasse en bas de la zone visible */
    var diff_bas = ( elt_offset.top + elt_h ) - ( viewport_offset.top + viewport_h );
    if ( diff_bas > 0 )
        h -= diff_bas;
    if (h < 0)
        h = 0;
    return h;
}

/*
 * Fonction permettant de retourner en pixel la largeur
 * visible d'un élément par rapport à la fenêtre du navigateur
 * @return integer w (largeur en pixel)
 */
function getVisibleWidth(elt) {
    var elt_w = elt.getWidth();
    var elt_offset = elt.cumulativeOffset();
    var viewport_w = document.viewport.getWidth();
    var viewport_offset = document.viewport.getScrollOffsets();
    var w_min_visible = viewport_offset.left;
    var w_max_visible = viewport_offset.left + viewport_w;
    var w = elt_w;
    /* Depasse à gauche de la zone visible */
    if (elt_offset.left < viewport_offset.left)
        w -= viewport_offset.left - elt_offset.left;
    /* Depasse à droite de la zone visible */
    var diff_droite = ( elt_offset.left + elt_w ) - ( viewport_offset.left + viewport_w );
    if ( diff_droite > 0 )
        w -= diff_droite;
    if (w < 0)
        w = 0;
    return w;
}

function fermerbulle() {
    $('bulle-info-wrapper').setStyle({display: 'none'});
}

/**
 * Ouvre un indicateur de chargement.
 * Si aucune div n'est passé en param, le loader s'affiche au milieu de l'écran, sinon il s'affiche au milieu de la div
 */
function ouvrirPreload(divCible) {
    if ($$('.zone-preload').length == 0) {
        var imageX = 53;
        var imageY = 53;
        if(!Object.isElement(divCible)) {
            var docDim = document.viewport.getDimensions();
            var offsetsScroll = document.viewport.getScrollOffsets();
            $$('.wrapper')[0].insert('<div id="zone-preload" class="chargement" style="width:'+imageX+'px;height:'+imageY+'px;position:absolute;left:'+(((docDim.width-imageX)/2)+offsetsScroll.left)+'px;top:'+(((docDim.height-imageY)/2)+offsetsScroll.top)+'px;z-index:9999;"></div>');
        } else {
            posX = divCible.offsetLeft + divCible.getWidth()/2 - imageX/2;
            posY = divCible.offsetTop + divCible.getHeight()/2 - imageY/2;
            divCibleParent = divCible.parentNode;
            divCibleParent.insert('<div id="zone-preload" class="chargement" style="width:'+imageX+'px;height:'+imageY+'px;position:absolute;left:'+posX+'px;top:'+posY+'px;z-index:9999;"></div>');
        }
    }
}

/* Ferme l'indicateur de chargement */

function fermerPreload() {
    if($('zone-preload')) {
        $('zone-preload').remove();
    }
}

/*
 * Fonction permettant de récupérer le premier entier à l'intérieur d'une chaine de charactère.
 * @param string str
 * @return integer
 */
function recupererEntier(str) {
    //On test si le paramètre est une chaine de charactère
    if(!Object.isString(str))
        return false;

    //Pattern utilisé pour la récupération d'un entier
    var pattern = /\d+/gi;

    //Retourne le premier entier ou null si rien trouvé
    return str.match(pattern)[0];
}

//Variables globales utilisées par classeMiniFicheAgatha et gestionMiniFicheAgatha
var derniereMiniFicheOuverte  = null;
var derniereActionInfoBulle   = "";

/**
 * gestion des affichages minifiches
 * @param DOMElement conteneur la liste des éléments sur lesquels on applique le rollover
 * @param DOMElement classeObservable l'élément de référence pour positionner la minifiche
 * @param Hash marges {'top': integer, 'bottom': integer, 'right': integer, 'left': integer}
 * @param boolean integrer_layout True si le conteneur référent intègre les conteneurs Header et footer
 * @param boolean positionner_souris True si on veut que la minifiche s'affiche au milieu de la position du curseur
 * @param Array listeActives liste des fiches déjà actives qu'on ne veut pas réactiver
 * @param DOMElement eltcache élément cache qui restreint l'affichage (ex: conteneur fixe d'un scroller
 */
function gestionMiniFicheAgatha(conteneur, classeObservable, marges, integrer_layout, positionner_souris, listeActives, eltcache) {
    var classeMiniFiche = 'minifiche-produit';
    var classeZone = 'zoneroll';
    
    var classeHackMSIE7 = 'type-C-IE7';

    var delaiAffichageMiniFiche = 0.3;

    //On retourne faux si le conteneur référent n'est pas un objet DOMElement
    if(!Object.isElement(conteneur))
        return false;

    // Si pas de cache valide, conteneur et cache sont confondus
    if(!Object.isElement(eltcache))
        eltcache = conteneur;

    if (listeActives == null || listeActives == false)
        listeActives = new Array();

    //TODO: rajouter un test? sur classeObservable

    //Un tableau contenant les marges à appliquer dans la zone d'affichage
    if(!marges)
        marges  = {'top': 4, 'bottom': 4, 'right': 4, 'left': 4};
    // Pour chaque observable
    classeObservable.each( function(o) {
        //Récupération de la minifiche associée
    	//alert(Element.id.substring(0,classeMiniFiche.length));
        var idMiniFiche = Element.readAttribute(o, 'rel');
        // Si pas d'attribut rel mais que l'id est de la forme zoneroll_id
        // on peut retrouver l'id de minifiche ainsi
        if ( !o.hasAttribute('rel') && o.id.substring(0,classeZone.length) == classeZone)
        	idMiniFiche = classeMiniFiche+'-'+o.id.substring(classeZone.length + 1);
        var miniFiche   = $(idMiniFiche);
        if (miniFiche == null)
        	console.log("minifiche inexistante : "+idMiniFiche);
        else
        {
	        // si la minifiche n'est pas déjà active
	        if (listeActives.indexOf(idMiniFiche) == -1) {
	            // On l'ajoute à la liste des actives
	            listeActives.push(idMiniFiche);
	            // Ajouter un nouvel évènement: entrée de l'objet
	            o.observe('mouseover', function(e) {
	
	                //On cache la dernière minifiche produit ouverte, évite des comportements de fenêtre ouvertes non voulus
	                if(Object.isElement(derniereMiniFicheOuverte)){
	                    //On enlève la classe du hack pour MSIE
	                    Element.removeClassName(derniereMiniFicheOuverte.parentNode.parentNode, classeHackMSIE7);
	                    //On cache la dernière minifiche produit ouverte
	                    derniereMiniFicheOuverte.hide();
	                }
	
	                //fiche_active = miniFiche;
	                if (miniFiche.getStyle('display') == 'none') {
	                    // Récupération des coordonnées à afficher
	                    if (positionner_souris){
	                        posMiniFiche = new classeMiniFicheAgatha(conteneur,miniFiche,null,marges,integrer_layout, eltcache).avecPositionSouris({posX: e.pageX, posY: e.pageY}).retournerLesPositions();
	                    } else {
	                        posMiniFiche = new classeMiniFicheAgatha(conteneur,miniFiche,o,marges,integrer_layout, eltcache).retournerLesPositions();
	                    }
	                    
	                    //On applique le Hack pour MSIE<8 pour les conteneur en position absolue
	                    if(Element.getStyle(miniFiche.parentNode.parentNode, 'position') === 'absolute'){
	                      Element.addClassName(miniFiche.parentNode.parentNode, classeHackMSIE7);
	                    }
	
	                    //On applique les règles CSS sur la miniFiche produit
	                    Element.setStyle(miniFiche, {
	                        'left': posMiniFiche.left+'px',
	                        'top': posMiniFiche.top+'px'
	                    });
	                    ajoutOnClickMiniFiche();
	                    new classeAnimationMiniFicheAgatha(miniFiche, derniereMiniFicheOuverte, 0.4, 0.3).lancerAnimation();
	
	                    //On sauvegarde la minifiche produit courante dans la variable
	                    derniereMiniFicheOuverte = miniFiche;
	                }
	            });
	            //Affichage de l'infobulle
	            /*var bouton_detail = $$('#'+idMiniFiche+' .bouton-preferences')[0];
	
	            Event.observe(bouton_detail, 'click', function() {
	
	                var idInfoBulle 	  = Element.readAttribute(bouton_detail, 'rel');
	                var infoBulle       = $(idInfoBulle);
	
	                if(infoBulle.style.display == 'block') {
	                    infoBulle.hide();
	                    return false;
	                }
	
	                var posBouton       = Element.positionedOffset(bouton_detail);
	                var posTop          = Element.getHeight(bouton_detail);
	                var posLeft         = Math.round((infoBulle.getWidth())/2);
	
	                //On affiche l'infobulle par rapport au bouton préférence de la minifiche produit
	                Element.setStyle(infoBulle, {
	                    display: 'block',
	                    left: (posBouton.left - posLeft +7)+'px',
	                    top: (posBouton.top + posTop +5)+'px'
	                });
	
	                return true;
	            });*/
	            miniFiche.observe("mouseout", function(e) {
	                //paliatif a la propagation de l'evenement cf http://www.quirksmode.org/js/events_mouse.html
	                if (!e){var e = window.event;}
	                
	                try {
						e.stopPropagation();
					}
					catch(er){
						e.cancleBubble = true;
					}                
	                    
	                var tg = (window.event) ? e.srcElement : e.target;


	                if (tg.className != classeMiniFiche)
	                {
	                	//console.log('tg non produit :'+tg.nodeName+', '+tg.className+', '+tg.id);
	                    //return false;
	                	// Si c'est le cas c'est la zone produit parente qui doit être considérée comme target !
	                	while(tg.className != classeMiniFiche && tg.nodeName != 'BODY')
	                	{
	                		tg=tg.parentNode;
	                	}
	                	if (tg.nodeName == 'BODY') {
	                		return false;
	                	}
	                }
	                try{
	                  var reltg = (e.relatedTarget) ? e.relatedTarget : e.toElement;
	                } catch(err){
	                  return false;
	                }
	                if (reltg) {
		                while (reltg != tg && reltg.nodeName != 'BODY')
		                    reltg= reltg.parentNode;
	                }
		            if (reltg== tg)
	                    return false;
	                // Mouseout took place when mouse actually left mini-fiche
	                // Handle event
	                if(tg.className == classeMiniFiche 
	                	&& Event.element(e).tagName != 'SELECT'
	                	&& Event.element(e).tagName != 'OPTION') {
	
	                    var bouton_detail = $$('#'+idMiniFiche+' .bouton-preferences')[0];
	                    /*var idInfoBulle 	  = Element.readAttribute(bouton_detail, 'rel');
	                    //On masque l'infoBulle
	                    $(idInfoBulle).hide();*/
	                    //On enlève la classe du hack pour MSIE
	                    Element.removeClassName(this.parentNode.parentNode, classeHackMSIE7);
	                    //On masque la minifiche produit
	                    this.hide();
	                }
	            });
	        }
        }
    });
    gestionPhotoProduit();
    return listeActives;
}

/*
 * Classe d'animation pour l'affichage des mini fiches produits
 * @param DOMElement miniFicheCourante (l'objet DOM de la minifiche produit qu'on veut afficher)
 * @param DOMElement derniereMiniFiche (l'objet DOM de la dernière minifiche produit affichée)
 * @param float duree (la durée de l'effet de fondue : exprimé en seconde)
 * @param float temporisation (le temps en secode de démarrage de l'effet)
 * @return Object classeAnimationMiniFicheAgatha (l'instance de la classe)
 */
var classeAnimationMiniFicheAgatha = Class.create()
classeAnimationMiniFicheAgatha.prototype = {
    //Initialisation de l'objet DOM de la mini fiche produit à afficher
    miniFicheCourante: null,

    //Initialisation de l'objet DOM de la dernière mini fiche affichée
    derniereMiniFiche: null,

    //Durée en secondes de l'animation
    duree: 0.4,

    //Durée en secondes de la temporisation
    temporisation: 0.5,

    //Constructeur
    initialize: function(miniFicheCourante, derniereMiniFiche, duree, temporisation) {

        if(Object.isElement(miniFicheCourante))
            this.miniFicheCourante = miniFicheCourante;
        else
            return false;

        if(Object.isElement(derniereMiniFiche))
            this.derniereMiniFiche = derniereMiniFiche;

        if(Object.isNumber(duree))
            this.duree = duree;

        if(Object.isNumber(temporisation)) {
        	if(isiPad) {
        		this.temporisation = 0;
        	} else {
        		this.temporisation = temporisation;
        	}
        }

        return this;

    },
    //Lance l'animation de fondue sur l'élément DOM
    lancerAnimation: function() {
        if(Object.isElement(this.derniereMiniFiche))
            this.stoperAutresAnimations();

        this.miniFicheCourante.effect = new Effect.Appear(this.miniFicheCourante, {
            from: 0.0,
            to: 1.0,
            duration: this.duree,
            afterSetup: function(obj) {
                obj.element.style.display = 'block'
            },
            delay: this.temporisation
        });

        return this;
    },
    //Stoppe l'animation des autres
    stoperAutresAnimations: function() {
        if(this.derniereMiniFiche.effect) {
            this.derniereMiniFiche.effect.cancel();
            this.derniereMiniFiche.hide();
        };
    }
};

var classeAnimationElementAgatha = Class.create();
classeAnimationElementAgatha.prototype = {

    //Attribut contenant la liste des éléments
    collection: new Array(),

    //Attribut contenant la fonction d'animation à utiliser
    methodeAnimation: Effect.Appear,

    //Attribut contenant les paramètres de configuration pour l'effet d'animation
    parametres: {delay: 0.0, speed: 0.2, duration: 0.6, speed: 0.2},

    //Constructeur
    initialize: function(collectionObjets, methodeAnimation) {
        //On vérifie que c'est un tableau
        if(Object.isArray(collectionObjets))
            this.collection = collectionObjets;
        else if(Object.isElement(collectionObjets)) {
            this.collection = new Array(collectionObjets);
        } else {
            return false;
        }

        //On vérifie que c'est une fonction
        if(Object.isFunction(methodeAnimation))
            this.methodeAnimation = methodeAnimation
    },
    //Déclanchement de l'animation sur les éléments
    lancerAnimation: function() {
        new Effect.multiple(this.collection, this.methodeAnimation, this.parametres);
    }
};

/**
 * Classe permettant de récupérer les positions absolue pour afficher la miniFiche
 * @param DOMElement conteneur
 * @param DOMElement miniFiche
 * @param DOMElement elementReferent l'élément déterminant le point de référence pour positionner la minifiche [Optionnel]
 * @param Hash marges {'top': integer, 'bottom': integer, 'right': integer, 'left': integer}
 * @param boolean test_hf True si le conteneur référent intègre les conteneurs Header et footer
 * @return Hash positions {'top': integer, 'left': integer}
 */
var classeMiniFicheAgatha = Class.create()
classeMiniFicheAgatha.prototype = {

    //La classe CSS du conteneur pour l'en tête du site
    classeCSSHeader: '.header-container',

    //La classe CSS du conteneur pour le pied de page du site
    classeCSSFooter: '.footer-container',

    //Initialisation de l'attribut position servant à placer la minifiche
    position: {'left': 0, 'top': 0},

    //Différence de positions absolue entre le conteneur référent et le conteneur de l'élément référent
    positionDiff: {'left': 0, 'top': 0},

    //Les positions de la zone d'affichage servent à établir un espace où la minifiche peut être affichée
    positionsZoneAffichage: {'leftMin': 0, 'leftMax': 0, 'topMin': 0, 'topMax': 0},

    //Constructeur de la classe, automatiquement appelé lorsque cette dernière est instancié
    initialize: function(conteneur, miniFiche, elementReferent, marges, test_hf, eltcache) {

        //Conteneur de référence pour déterminer la zone d'affichage des minifiches
        if(Object.isElement(conteneur))
            this.conteneur = conteneur;
        //On retourne faux si le conteneur référent n'est pas un objet DOMElement
        else
            return false;

        //L'objet Dom de la mini fiche
        if(Object.isElement(miniFiche))
            this.miniFiche = miniFiche;
        //On retourne faux si l'élément n'est pas un objet DOMElement
        else
            return false;

        //Un tableau contenant les marges à appliquer dans la zone d'affichage
        if(!marges)
            this.marges  = {'top': 4, 'bottom': 4, 'right': 4, 'left': 4};
        else
            this.marges  = marges;

        //Les positions par défaut de la miniFiche selon l'élément référent
        if(Object.isElement(elementReferent)) {
            //Récupération des positions de l'élément référent selon son conteneur
            this.position = Element.positionedOffset(elementReferent);
            //Si le parent offset de l'élément référent n'est pas le même que celui passé en paramètre
            //On va calculer la différence de positions entre ces deux conteneurs
            if(elementReferent.getOffsetParent() != conteneur) {
                this.positionDiff = {
                    left: (elementReferent.getOffsetParent().cumulativeOffset().left - conteneur.cumulativeOffset().left),
                    top: (elementReferent.getOffsetParent().cumulativeOffset().top - conteneur.cumulativeOffset().top)
                };
            }

        };

        //Calcul de l'offset de la surface visible de l'écran de l'utilisateur (en prenant en compte la présence de scrollbar)
        var offset_referent = {
            left: (document.viewport.getScrollOffsets().left - Element.cumulativeOffset(conteneur).left),
            top: (document.viewport.getScrollOffsets().top - Element.cumulativeOffset(conteneur).top)
        };

        // Calcul de l'offset du cache par rapport au conteneur
        var offset_eltcache = {
            left: (Element.cumulativeOffset(eltcache).left - Math.max(Element.cumulativeOffset(conteneur).left, document.viewport.getScrollOffsets().left)),
            top: (Element.cumulativeOffset(eltcache).top - Math.max(Element.cumulativeOffset(conteneur).top, document.viewport.getScrollOffsets().top))
        };

        //On détermine les positions de la zone d'affichage
        this.positionsZoneAffichage.leftMin = this.marges.left;
        if (offset_referent.left > 0)
            this.positionsZoneAffichage.leftMin += offset_referent.left;
        if (offset_eltcache.left > 0)
            this.positionsZoneAffichage.leftMin += offset_eltcache.left;
        this.positionsZoneAffichage.topMin = this.marges.top;
        if (offset_referent.top > 0)
            this.positionsZoneAffichage.topMin += offset_referent.top;
        if (offset_eltcache.top > 0)
            this.positionsZoneAffichage.topMin += offset_eltcache.top;

        this.positionsZoneAffichage.leftMax = this.positionsZoneAffichage.leftMin + Math.min(getVisibleWidth(conteneur),getVisibleWidth(eltcache)) - this.miniFiche.getWidth() - this.marges.right - this.marges.left;
        this.positionsZoneAffichage.topMax  = this.positionsZoneAffichage.topMin + Math.min(getVisibleHeight(conteneur),getVisibleHeight(eltcache)) - this.miniFiche.getHeight() - this.marges.bottom - this.marges.top;

        if (test_hf) {
            this.positionsZoneAffichage.topMin += getVisibleHeight($$(this.classeCSSHeader)[0]);
            this.positionsZoneAffichage.topMax -= getVisibleHeight($$(this.classeCSSFooter)[0]);
        }
    },
    //Calcul les positions
    calculerLesPositions: function() {

        this.position.left  = this.position.left + this.positionDiff.left;
        this.position.top   = this.position.top + this.positionDiff.top;

        if (this.position.left > this.positionsZoneAffichage.leftMax)
            this.position.left = this.positionsZoneAffichage.leftMax;
        else if (this.position.left < this.positionsZoneAffichage.leftMin)
            this.position.left = this.positionsZoneAffichage.leftMin;
        if (this.position.top > this.positionsZoneAffichage.topMax)
            this.position.top = this.positionsZoneAffichage.topMax;
        else if (this.position.top < this.positionsZoneAffichage.topMin)
            this.position.top = this.positionsZoneAffichage.topMin;

        this.position.left  = this.position.left - this.positionDiff.left;
        this.position.top   = this.position.top - this.positionDiff.top;
    },
    avecPositionSouris: function(positionsCurseur) {
        var offset = this.conteneur.cumulativeOffset();
        this.position.left  = positionsCurseur.posX - offset.left - (this.miniFiche.getWidth()/2);
        this.position.top   = positionsCurseur.posY - offset.top - (this.miniFiche.getHeight()/2);

        return this;
    },
    //Retourne les positions
    retournerLesPositions: function() {

        //On calcule les limites de la zone d'affichage
        this.calculerLesPositions();

        return this.position;
    }
};

/**
 * Class responsable de la mise à jour du lien 'ajout' au panier dans la mini-fiche
 */
OptionsMiniFiche = Class.create();
OptionsMiniFiche.prototype = {
    initialize: function(id_produit, config) {
        this.config       = config;
        if(this.config.prefixe != null) {
        	idElementAvecPrefixe = '#'+this.config.prefixe+'-minifiche-produit-'+id_produit;
        } else {
        	idElementAvecPrefixe = ' ';
        }
        this.selectBox    = $$(idElementAvecPrefixe+' #select-choix-taille-'+id_produit)[0];
        this.boutonPanier = $$(idElementAvecPrefixe+' #bouton-ajout-panier-'+id_produit)[0];
        Event.observe(this.selectBox, 'change', this.mettreAJourLienApresChangementTaille.bind(this));
    	this.initialiserLeLien();
    },
    mettreAJourLienApresChangementTaille: function(event) {
    	  var element = Event.element(event);
          var id_taille = element.value;
          this.mettreAJourLienMiniFiche(id_taille);
    },
    mettreAJourLienMiniFiche: function(id_taille) {
		if(this.config[id_taille]){
		    var id = this.config[id_taille].id;
		    var url = this.config[id_taille].url;
		    
		    if(url.length>0 && id) {
		        this.boutonPanier.setAttribute('href',url);
		        this.boutonPanier.show();
		    } else {
		        this.boutonPanier.hide();
		    }    	
		} else {
			this.boutonPanier.hide();
		}
    },
    initialiserLeLien: function(){
    	 this.mettreAJourLienMiniFiche(this.selectBox.value);
    }
};

var classeGrilleMosaiqueTypeB = Class.create();
classeGrilleMosaiqueTypeB.prototype = {
    largeurElementUnitaire: 120,

    hauteurElementUnitaire: 80,
    
    hauteur: 0,

    conteneur: null,

    elements: null,

    attributPositionX: 'posx',

    attributPositionY: 'posy',

    animation: false,

    initialize: function(conteneur, collectionElementsDom, animation) {
        if(Object.isElement(conteneur))
            this.conteneur = conteneur;
        else
            return false;

        if(Object.isArray(collectionElementsDom))
            this.elements = collectionElementsDom;
        else
            return false;

        if(animation)
            this.animation = true;

        this.redimensionnerHauteurConteneur();
    },
    rechercherHauteurConteneur: function() {
        var derniereGrandeHauteur = 0;

        this.elements.each( function(e) {
            if(Object.isElement(e)) {
                var hauteurCourante = (Element.getHeight(e) + (parseInt(Element.readAttribute(e, this.attributPositionY)) * this.hauteurElementUnitaire));

                if((hauteurCourante > derniereGrandeHauteur))
                    derniereGrandeHauteur = hauteurCourante;
            }
        }.bind(this));
        
        this.hauteur = derniereGrandeHauteur;
        
        return derniereGrandeHauteur;
    },
    redimensionnerHauteurConteneur: function() {
        var derniereGrandeHauteur = this.rechercherHauteurConteneur();
        
        Element.setStyle(this.conteneur, {height: derniereGrandeHauteur+'px'});
    },
    placerLesElements: function() {
        this.elements.each( function(element) {
            if(Object.isElement(element)) {
                this.placerUnElement(element);
            }
        }.bind(this));
    },
    placerUnElement: function(elementDom) {
        var position = {
            x: Element.readAttribute(elementDom, this.attributPositionX),
            y: Element.readAttribute(elementDom, this.attributPositionY)
        };

        Element.setStyle(elementDom, {
            right: (position.x * this.largeurElementUnitaire)+'px',
            top: (position.y * this.hauteurElementUnitaire)+'px',
            position: 'absolute'
        });

        if(this.animation)
            Element.setStyle(elementDom, {display: 'none'});

        this.ajouterUnElement(elementDom);
    },
    ajouterUnElement: function(elementDom) {
        this.conteneur.appendChild(elementDom);
    }
};


/**
 * Classe responsable du comportement du libellé des champs recherche et newsletter
 */
LibelleParDefautChampTexte = Class.create();
LibelleParDefautChampTexte.prototype = {
    initialize: function() {
        this.champs = $$('.libelle-par-defaut');
        this.champs.each(function(element) {
        	Event.observe(element, 'click', this.supprimerLibelle);
        	Event.observe(element, 'blur', this.insererLibelle);
        }.bind(this));
    },
    supprimerLibelle: function(event) {
        var element = Event.element(event);
        if(element.readAttribute('rel') == element.value)
        	element.value = ''; 
    },
    insererLibelle: function(event) {
        var element = Event.element(event);
        if(element.value == '')
        	element.value = element.readAttribute('rel'); 
    }
};

Event.observe(window, 'load', function() {
	new LibelleParDefautChampTexte();
});

//Affiche la photo réelle du produit quand un placeholder est utilisé
function gestionPhotoProduit() {
	  images = $$('.photo-produit .image-produit, .minifiche-produit .cadre');
	  i = 0;
	  images.each(function(image) {i++;
	    json = image.readAttribute('rev').evalJSON();
	    if(json.used === 0) {
	      image.writeAttribute('src', json.imageUrl);
	      json.used = 1;
	      image.writeAttribute('rev',Object.toJSON(json));
	    }
	  });
}