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 ;

	}

}