Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.observation.indicateurs;

import org.tela_botanica.client.i18n.Msg;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;

import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.ToolTip;

/**
 * Un panneau affichant une image generique provenant d eflore
 * 
 * @author David Delon
 * 
 */
public class ImageGeneriqueVue extends Panel implements Rafraichissable {

        /**
         * Le médiateur associé
         */
        
        private ObservationMediateur observationMediateur = null;
        
        
        /**
         * l'image à afficher
         */
        private Image image = new Image();
        
        private String urlImage = "" ;
        private String urlImageMax = "" ;
        
        private HTML htmlVide = new HTML();
        
        
        private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ;
        
        private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </div>") ;
        
        /**
         * Constructeur sans argument (privé car ne doit pas être utilisé)
         */
        
        @SuppressWarnings("unused")
        private ImageGeneriqueVue() {
                super();
        }

        /**
         * Constructeur avec argument
         * @param obs le médiateur à associer
         */
        
        
        public ImageGeneriqueVue(ObservationMediateur obs) {
                
                        
                this.observationMediateur = obs;
                imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ;
                image = new Image() {

                        @Override
                        public void onBrowserEvent(Event event) {

                                // lors du double clic
                                if (Event.ONDBLCLICK == DOM.eventGetType(event)) {

                                        // on notifie le médiateur
                                        agrandirImage() ;
                                }
                        }
                        
                };
                
                tp.applyTo(image.getElement()) ;
                
                
                this.setCls("x-image-gen") ;
                
                imgZoom.setConstrain(true);
                imgZoom.setAutoHeight(true) ;
                imgZoom.setAutoWidth(true) ;
                
                htmlVide.setHeight("0px");
                htmlVide.setVisible(false);

                add(image);
                add(htmlVide);
                image.setPixelSize(150, 150);
                image.sinkEvents(Event.ONDBLCLICK);
                
                afficherImageSinonAfficherMessage(false);
                // on ajoute les listeners
                ajouterListeners();
        }


        /**
         * Affichage image generique
         * 
         */
        
        @Override
        public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) {

                // si on recoit une String contenant une URL
                if (nouvelleDonnees instanceof String []) {
                        String [] lecteurDonnees = (String []) nouvelleDonnees;
                        
                        urlImage=lecteurDonnees[0];
                        urlImageMax=lecteurDonnees[1];
                        
                        if (urlImage == null || urlImage.equals("null") || urlImage.length()==0 || urlImage.equals("")) {
                                afficherHtmlVide();
                                image.setVisible(false);
                        }
                        else {
                                afficherImageSinonAfficherMessage(true);
                                image.setUrl(urlImage);
                                image.setPixelSize(150, 150);
                                verifierEtRetaillerImage();
                        }
                } else {
                        afficherImageSinonAfficherMessage(false);
                }
                
                observationMediateur.deMasquerChargementInfosObservations() ;
                                
        }
        
        private void afficherImageSinonAfficherMessage(boolean afficherImage) {
                if(afficherImage) {
                        htmlVide.setVisible(false);
                } else {
                        afficherHtmlVide();
                }
                image.setVisible(afficherImage);
        }
        
        private void afficherHtmlVide() {  
                String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-image-taxon")+"</div>";
                htmlVide.setHeight("150px");
                htmlVide.setHTML(htmlDivVide);
                htmlVide.setVisible(true);
        }
        
        public void agrandirImage() {
                
                if(!imgZoom.isVisible())
                {
                        imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlImageMax+"\" />") ;
                        imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ;
                        imgZoom.show(this.getElement()) ;
                } else {
                        imgZoom.hide();
                }       
        }

        
        /**
         * Ajoute les listeners pour la gestions d'évènement
         */
        public void ajouterListeners() {
                
        }
        
        public void raz() {
                image.setUrl("");
        }
        
        public void verifierEtRetaillerImage() {
                // si l'image est nulle
                if (image == null) {
                        // on ne fait rien
                        return;
                }
                

                // on prend la taille originale de l'image
                int originalX = image.getWidth();
                int originalY = image.getHeight();

                // on la transforme en float (la division entre entier donne de curieux
                // résultats)
                float fOriginalX = (new Float(originalX)).floatValue();
                float fOriginalY = (new Float(originalY)).floatValue();

                // et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
                float rapportTaille = fOriginalX / fOriginalY;

                // la nouvelle taille est pour le moment égale à l'ancienne
                int nouvelleTailleX = originalX;
                int nouvelleTailleY = originalY;

                // on prend la taille du conteneur
                int tailleConteneurX = getWidth();
                int tailleConteneurY = getHeight();
                
                int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
                int max = Math.min(maxConteneur, 300);
                
                // si l'image ne rentre pas telle quelle (longueur ou hauteur trop
                // grande)      
                // si la longueur de l'image est la plus grande des deux
                        
                        int maxImage = Math.max(originalX, originalY);
                        
                        if(maxImage == originalX) {
                                // on prend la longueur comme taille de référence, qu'on met à
                                // la longueur du conteneur
                                nouvelleTailleX = max;
                                // et on recalcule la hauteur, par rapport à la nouvelle
                                // longueur, en gardant le format de 'limage
                                nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
                                                / rapportTaille);
                        } 
                        else
                        {       
                                // si la hauteur est la plus grande, on fait le même genre
                                // d'opération en prenant la hauteur comme référence
                                nouvelleTailleY = max;
                                nouvelleTailleX = (int) Math.floor(nouvelleTailleY
                                                * rapportTaille);
                        }

                // on modifie enfin la taille de l'image pour qu'elle soit affichée
                        image.setPixelSize(nouvelleTailleX ,
                                        nouvelleTailleY);
                
                doLayout();
        }
}