Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;


import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;

import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Widget;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;

/**
 * Panneau d'affichage d'une image avec des boutons précdents et suivant
 * @author aurelien
 *
 */
public class ZoomImageVue extends Panel implements Rafraichissable {
        
        /**
         * Le médiateur associé à la vue
         */
        private ImageMediateur iMediateur = null ;
        
        /**
         * Panneau conteneur pour l'image
         */
        private Panel imageConteneur = null ;
        /**
         * l'image à afficher
         */
        private Image image = new Image("vide.jpg") ;
        /**
         * Bouton précédent
         */
        private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
        /**
         * Bouton suivant
         */
        private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
        
        /**
         * Taille originale Y de l'image
         */
        private int imageHeight = 0 ;
        
        /**
         * Taille originale X de l'image
         */
        private int imageWidth = 0 ;
        
        /**
         * Booleen d'initalisation général
         */
        private boolean initialise = false ;
        
        /**
         * Booleen d'initalisation du conteneur d'image
         */
        private boolean conteneurInitialise = false ;
        
        /**
         * Constructeur sans argument (privé car ne doit être utilisé)
         */
        @SuppressWarnings("unused")
        private ZoomImageVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec argument
         * @param im le médiateur à associer à la vue 
         */
        public ZoomImageVue(ImageMediateur im)
        {
                super("Zoom");
                setId("x-view-zoom-panel") ;
                // on associe le médiateur
                iMediateur = im ;
                
                prev.setStylePrimaryName("x-view-zoom-button-p") ;
                suiv.setStylePrimaryName("x-view-zoom-button-s") ;

                
                // on crée une image qui gère le double clic et la roulette de la souris
                image = new Image() {
                        
                        public void onBrowserEvent(Event event) {
                                
                                // lors du double clic
                                if (Event.ONDBLCLICK == DOM.eventGetType(event)) {

                                        // on notifie le médiateur
                                        getIMediateur().doubleClicZoomImage();
                                }
                                
                                // lors d'un déplacement de la roulette
                                if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {

                                        // on simule un clic sur le bouton précédent
                                        if(event.getMouseWheelVelocityY() >= 1)
                                        {
                                                prev.click() ;          
                                        }
                                        
                                        // ou suivant
                                        if(event.getMouseWheelVelocityY() <= -1)
                                        {
                                                suiv.click() ;
                                        }
                                }
                        }
                };
                
                
                this.setHeader(false) ;
                
                
                imageConteneur = new Panel()  ;
                imageConteneur.setBorder(false);
                
                imageConteneur.add(image) ;
                imageConteneur.setId("x-view-zoom-img") ;
                
                // il n'existe pas de méthode pour ajouter un listener pour le double clic sur une image
                // alors on lui dit manuellement de capter l'évènement double clic
                image.sinkEvents(Event.ONDBLCLICK);
                image.sinkEvents(Event.ONMOUSEWHEEL) ;
                
                // l'image de base est vide
                image.setUrl("vide.jpg");
                
                this.setLayout(new BorderLayout());
                
                prev.setWidth("60px");
                suiv.setWidth("60px");
                
                this.add(prev,new BorderLayoutData(RegionPosition.WEST));
                this.add(imageConteneur,new BorderLayoutData(RegionPosition.CENTER));
                this.add(suiv,new BorderLayoutData(RegionPosition.EAST));
                
                imageConteneur.setMaskDisabled(true) ;
                this.setBorder(false);
                
                conteneurInitialise = true ;
                initialise = true ;
                
                // on ajoute les listeners
                ajouterListeners();

        }

        /**
         * Méthode héritée de l'interface rafraichissable
         * @param nouvelleDonnees les nouvelles données
         * @param repandreRafraichissement le booleen qui dit si on doit répnadre l'évènement
         */
        public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
                
                // si on reçoit une string
                if(nouvelleDonnees instanceof String[] && initialise && conteneurInitialise)
                {
                        String[] infos = (String[])nouvelleDonnees ;
                        // c'est l'url de l'image qu'on associe à la vue
                        getImage().setUrl(infos[0]);
                        
                        
                        if(infos[1] != null && infos[2] != null)
                        {
                                int x = Integer.parseInt(infos[1]) ;
                                int y = Integer.parseInt(infos[2]) ;
                                
                                setTailleImage(x,y) ;
                                
                                verifierEtRetaillerImage() ;
                        }
                }
                else
                {
                        // sinon on met une image vide
                        getImage().setUrl("vide.jpeg") ;
                }
        }
        
        /**
         * Desactive visuellement le panneau et les boutons
         */
        public void desactiverPanneau()
        {
                getImage().setUrl("vide.jpeg") ;
                prev.setEnabled(false) ;
                suiv.setEnabled(false);
        }
        
        /**
         * Active visuellement le panneau et les boutons
         */
        public void activerPanneau()
        {
                prev.setEnabled(true);
                suiv.setEnabled(true);
        }
        
        /**
         * Ajoute les listeners pour la gestions d'évènement
         */
        public void ajouterListeners()
        {
                
                // gestion du clic sur le bouton précedent
                prev.addClickListener(new ClickListener() {

                        // en cas de clic
                        public void onClick(Widget sender) {
                                // on notifie le médiateur
                                getIMediateur().clicBoutonZoomImage("prev");
                        }
                        
                });
                
                // gestion du clic sur le bouton suivant
                suiv.addClickListener(new ClickListener() {

                        // en cas de clic
                        public void onClick(Widget sender) {
                                // on notifie le médiateur     
                                getIMediateur().clicBoutonZoomImage("suiv");
                        }
                        
                });
                
                // gestion du redimensionnement
                this.addListener(new PanelListenerAdapter() {
                        
                        // lors d'un redimensionnement de l'application
                        
                        public void onBodyResize(Panel panel,java.lang.String width,java.lang.String height)
                        {
                                // on vérifie et on retaille l'image
                                verifierEtRetaillerImage() ;
                        }
                }) ;
                
                // gestion du redimensionnement lors de l'affichage du conteneur
                imageConteneur.addListener(new PanelListenerAdapter() {
                        
                        // avant de finir d'afficher
                        
                        public void onAfterLayout(Container self)
                        {
                                // on redimensionne
                                verifierEtRetaillerImage() ;
                        }
                }) ;
                
        }

        /**
         * Verifie si l'image est plus grande que le conteneur et la retaille le cas echeant
         */
        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 = getTailleImage()[0] ;
                int originalY = getTailleImage()[1]     ;
                
                // 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 = imageConteneur.getWidth() ;
                int tailleConteneurY = imageConteneur.getHeight() ;
                
                // si celle-ci est égale à 0 (conteneur mal initialisé)
                /*if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0)
                {
                        // on essaie de la calculer en fonction de la taille du parent et des frères
                        tailleConteneurY = this.getHeight() ;
                        tailleConteneurX = this.getWidth() - prev.getOffsetWidth() * 2 ;
                        
                }*/
                 
                // si l'image ne rentre pas telle quelle (longueur ou hauteur trop grande)
                if(originalY > tailleConteneurY || originalX > tailleConteneurX)
                {
                        // si la longueur de l'image est la plus grande des deux
                        if(originalX > originalY)
                        {               
                                // on prend la longueur comme taille de référence, qu'on met à la longueur du conteneur
                                nouvelleTailleX = tailleConteneurX ;
                                // 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 = tailleConteneurY ;
                                nouvelleTailleX = (int)Math.floor(nouvelleTailleY*rapportTaille) ;
                        }               
                }
                
                // on modifie enfin la taille de l'image pour qu'elle soit affichée
                getImage().setSize(""+nouvelleTailleX+"px", ""+nouvelleTailleY+"px") ;          
        }

        /**
         * Accesseur pour le médiateur
         * @return le médiateur associé à la vue
         */
        public ImageMediateur getIMediateur() {
                return iMediateur;
        }

        /**
         * Accesseur au conteneur de l'image
         * @return le conteneur de l'image
         */
        public Image getImage() {
                return image;
        }

        /**
         * Accesseur pour le bouton précédent
         * @return le bouton précédent
         */
        public com.google.gwt.user.client.ui.Button getPrev() {
                return prev;
        }

        /**
         * Accesseur pour le bouton suivant
         * @return le bouton suivant
         */
        public com.google.gwt.user.client.ui.Button getSuiv() {
                return suiv;
        }
        
        /**
         * Setter pour la taille de l'image
         * @param X la largeur en pixels
         * @param Y la hauteur en pixels
         */
        public void setTailleImage(int x, int y)
        {
                imageHeight = y ;
                imageWidth = x ;
        }
        
        /**
         * renvoie la taille originale de l'image
         * @return un tableau de deux entiers contenant la largeur puis la hauteur
         */
        public int[] getTailleImage()
        {
                int[] taille = {imageHeight,imageWidth} ;
                
                return taille ;
        }

        public Panel getImageConteneur() {
                
                return imageConteneur ;
                
        }
}