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 org.tela_botanica.client.modeles.Configuration;

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.ClickListener;

import com.google.gwt.user.client.ui.Image;

import com.google.gwt.user.client.ui.MenuItem;

import com.google.gwt.user.client.ui.Widget;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.core.RegionPosition;

import com.gwtext.client.dd.DragData;

import com.gwtext.client.dd.DragSource;

import com.gwtext.client.dd.DropTarget;

import com.gwtext.client.dd.DropTargetConfig;

import com.gwtext.client.widgets.BoxComponent;

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Container;

import com.gwtext.client.widgets.Panel;

import com.gwtext.client.widgets.event.PanelListener;

import com.gwtext.client.widgets.event.PanelListenerAdapter;

import com.gwtext.client.widgets.grid.GridDragData;

import com.gwtext.client.widgets.layout.BorderLayout;

import com.gwtext.client.widgets.layout.BorderLayoutData;

import com.gwtext.client.widgets.menu.BaseItem;

import com.gwtext.client.widgets.menu.Item;

import com.gwtext.client.widgets.menu.Menu;

import com.gwtext.client.widgets.menu.event.MenuListener;

import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;

/**

 * Panneau d'affichage d'une image avec des boutons précdents et suivant

 *

 * @author aurelien

 *

 */

public class MiniZoomImageVue extends Panel implements Rafraichissable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ObservationMediateur oMediateur = null;

	/**

	 * Panneau conteneur pour l'image

	 */

	private Panel imageConteneur = null;

	/**

	 * l'image à afficher

	 */

	private Image image = new Image("");

	/**

	 * 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;

	/**

	 * Identifiant de l'image

	 */

	private String idImage = "0" ;

	private String[] infosImages = null ;

	private int index = 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 MiniZoomImageVue() {

		super();

	}

	/**

	 * Constructeur avec argument

	 *

	 * @param im

	 *            le médiateur à associer à la vue

	 */

	public MiniZoomImageVue(ObservationMediateur im) {

		super("Image liées");

		setId("x-view-mini-zoom-panel");

		// on associe le médiateur

		oMediateur = 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 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();

					}

				}

				if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) {

					event.preventDefault() ;

					int[] xy = {event.getClientX(),event.getClientY()} ;

					afficherMenu(xy) ;

				}

			}

		};

		image.setPixelSize(150, 150);

		infosImages = new String[0] ;

		this.setHeader(true);

		imageConteneur = new Panel() ;

		imageConteneur.setBorder(false);

		imageConteneur.add(image);

		imageConteneur.setId("x-view-mini-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);

		image.sinkEvents(Event.ONCONTEXTMENU) ;

		// l'image de base est vide

		image.setUrl("");

		this.setLayout(new BorderLayout());

		prev.setWidth("15%");

		suiv.setWidth("15%");

		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[])nouvelleDonnees).length != 0) {

			infosImages = (String[]) nouvelleDonnees;

			index = 0 ;

			afficherImage() ;

		} else {

			// sinon on met une image vide

			infosImages = new String[0] ;

			getImage().setUrl("ill_liaison.png");

			imageWidth = getImage().getWidth();

			imageHeight = getImage().getHeight();

			verifierEtRetaillerImage();

		}

	}

	public void afficherImage()

	{

		// c'est l'url de l'image qu'on associe à la vue

		if(infosImages.length != 0)

		{

			activerPanneau() ;

			getImage().setUrl(convertirIdEnUrl(infosImages[index]));

			imageWidth =getImage().getWidth();

			imageHeight = getImage().getHeight();

			verifierEtRetaillerImage();

		}

		else

		{

			desactiverPanneau() ;

		}

	}

	/**

	 * Desactive visuellement le panneau et les boutons

	 */

	public void desactiverPanneau() {

		getImage().setUrl("");

		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) {

				if(infosImages.length != 0) {

					if(index == 0)

					{

						index = infosImages.length - 1 ;

					}

					else

					{

						index-- ;

					}

					afficherImage() ;

				}

			}

		});

		// gestion du clic sur le bouton suivant

		suiv.addClickListener(new ClickListener() {

			// en cas de clic

			public void onClick(Widget sender) {

				if(infosImages.length != 0) {

					if(index == infosImages.length - 1)

					{

						index = 0 ;

					}

					else

					{

						index++ ;

					}

					afficherImage() ;

				}

			}

		});

	}

	/**

	 * Accesseur pour le médiateur

	 *

	 * @return le médiateur associé à la vue

	 */

	public ObservationMediateur getIMediateur() {

		return oMediateur;

	}

	/**

	 * Accesseur au conteneur de l'image

	 *

	 * @return le conteneur de l'image

	 */

	public Image getImage() {

		return image;

	}

	/**

	 * Acesseurs pour l'identifiant de l'image

	 * @return l'id de l'image

	 */

	public String getIdImage()

	{

		return infosImages[index] ;

	}

	/**

	 * 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;

	}

	/**

	 * Setteur pour l'identifiant de l'image

	 * @param id le nouvel identifiant

	 */

	public void setIdImage(String id)

	{

		idImage = id ;

	}

	/**

	 * 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;

	}

	/**

	 * Accesseur pour le conteneur de l'image

	 * @return le conteur de l'image

	 */

	public Panel getImageConteneur() {

		return imageConteneur;

	}

	public void raz() {

		infosImages = new String[0] ;

		getImage().setUrl("");

	}

	public void supprimerLiaisonImage() {

		if(infosImages.length > 0) {

			getImage().setUrl("") ;

			int nouvelleTaille = infosImages.length - 1 ;

			int indexSupp = index ;

			String[] nouveauInfosImages = new String[nouvelleTaille] ;

			int j = 0 ;

			for(int i = 0 ; i < infosImages.length ; i++) {

				if(i != indexSupp) {

					nouveauInfosImages[j] = infosImages[i] ;

					j++ ;

				}

			}

			infosImages = nouveauInfosImages ;

			index = 0 ;

			afficherImage() ;

		}

	}

	public void afficherMenu(int[] xy) {

		Menu mn = new Menu() ;

		final Item suppLiaison = new Item("Supprimer la liaison") ;

		mn.addItem(suppLiaison) ;

		mn.addListener(new MenuListenerAdapter() {

			public void onItemClick(BaseItem item, EventObject e) {

				// si c'est l'aide

				if (item.equals(suppLiaison)) {

					// on notifie le médiateur

					getIMediateur().supprimerLiaisonObsImage() ;

				}

			}

		}) ;

		mn.showAt(xy) ;

	}

	public String convertirIdEnUrl(String idImg)

	{

		int maxZeros = 9 - idImg.length();

		for (int j = 0; j < maxZeros; j++) {

			idImg = "0" + idImg;

		}

		String baseUrl = Configuration.getImageBaseUrl() ;

		String dossierNv1 = idImg.substring(0, 3);

		String dossierNv2 = idImg.substring(3, 6);

		String fichierNv = idImg.substring(6, 9);

		String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv;

		String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 };

		String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/"

		+ infosFichier[0] + "_M.jpg";

		return urlImg ;

	}

	/**

	 * 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();

		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

		int[] dim = calculerDimensions(getTailleImage());

		getImage().setSize("" + dim[0] + "px",

				"" + dim[1] + "px");

		doLayout();

	}

	public int[] calculerDimensions(int[] tailleXY) {

		float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;

        float tailleOr = Math.min(300,imageConteneur.getWidth()) ;

        float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;

        float[] XYresize = new float[2];

        if(maxTaille == tailleXY[0]) {

            float rapport = tailleXYf[1]/tailleXYf[0] ;

            XYresize[0] = tailleOr ;

            XYresize[1] = tailleOr*rapport ;

        }else {

            float rapport = tailleXYf[0]/tailleXYf[1] ;

            XYresize[1] = tailleOr ;

            XYresize[0] = tailleOr*rapport ;

        }

        int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;

        return res;

    }

}