Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.image;

import org.tela_botanica.client.image.ImageMediateur;

import org.tela_botanica.client.interfaces.Rafraichissable;

import com.google.gwt.core.client.GWT;

import com.google.gwt.core.client.JavaScriptObject;

import com.google.gwt.event.dom.client.ClickEvent;

import com.google.gwt.event.dom.client.ClickHandler;

import com.google.gwt.event.dom.client.LoadEvent;

import com.google.gwt.event.dom.client.LoadHandler;

import com.google.gwt.event.dom.client.MouseWheelEvent;

import com.google.gwt.event.dom.client.MouseWheelHandler;

import com.google.gwt.user.client.Event;

import com.google.gwt.user.client.Timer;

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

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

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

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

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

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

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

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

import com.gwtext.client.core.AnimationConfig;

import com.gwtext.client.core.Direction;

import com.gwtext.client.core.DomConfig;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.core.Ext;

import com.gwtext.client.core.ExtElement;

import com.gwtext.client.core.Function;

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

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Container;

import com.gwtext.client.widgets.Panel;

import com.gwtext.client.widgets.ToolTip;

import com.gwtext.client.widgets.Toolbar;

import com.gwtext.client.widgets.ToolbarButton;

import com.gwtext.client.widgets.ToolbarTextItem;

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

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

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

/**

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

	/**

	 * Identifiant de l'image

	 */

	private String idImage = "0" ;

	/**

	 * Booleen d'initalisation général

	 */

	private boolean initialise = false;

	private Panel infosTaxon = new Panel();

	/**

	 * Booleen d'initalisation du conteneur d'image

	 */

	private boolean conteneurInitialise = false;

	private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour revenir à la vue précédente, utilisez la roulette ou les boutons fléchés pour faire défiler les images </div>") ;

	/**.

	 * boolean de gestion du double clic

	 */

	private boolean enClic = false;

	private ToolbarButton modeZoom = null;

	private ToolbarTextItem valeurZoom = new ToolbarTextItem("x 1");

	protected boolean scroll = 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();

		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

		//imageConteneur.sinkEvents(Event.ONMOUSEWHEEL);

		// l'image de base est vide

		image.setUrl("vide.jpg");

		this.setLayout(new BorderLayout());

		prev.setWidth("60px");

		suiv.setWidth("60px");

		modeZoom = new ToolbarButton("Mode Zoom");

		Toolbar tb = new Toolbar();

		tb.addButton(modeZoom);

		tb.addItem(valeurZoom);

		//setTopToolbar(tb);

		infosTaxon = new Panel();

		infosTaxon.setHeader(false);

		//infosTaxon.setBorder(false);

		infosTaxon.setHeight("30px");

		this.add(prev, new BorderLayoutData(RegionPosition.WEST));

		this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));

		this.add(suiv, new BorderLayoutData(RegionPosition.EAST));

		this.add(infosTaxon, new BorderLayoutData(RegionPosition.SOUTH));

		imageConteneur.setMaskDisabled(true);

		this.setBorder(false);

		conteneurInitialise = true;

		initialise = true;

		configDragAndDrop() ;

		// on ajoute les listeners

		ajouterListeners();

		tp.setDismissDelay(1050);

		tp.applyTo(image.getElement()) ;

	}

	/**

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

		//niveauZoom = 1;

		// 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

			if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {

				getImage().setUrl(infos[0]);

				int x = Integer.parseInt(infos[1]);

				int y = Integer.parseInt(infos[2]);

				setTailleImage(x, y);

				setIdImage(infos[3]) ;

				String infosTaxon = "" ;

				if(infos.length == 5 && infos[4] != null)  {

					infosTaxon = infos[4];

				}

				setInfosTaxon(infosTaxon);

				verifierEtRetaillerImage();

			}

		} else {

			// sinon on met une image vide

			getImage().setUrl("vide.jpg");

		}

	}

	/**

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

	}

	public void masquerChargement() {

		ExtElement imgEl = Ext.get(imageConteneur.getElement());

		if(imgEl != null) {

			imgEl.mask("Chargement");

		}

	}

	public void demasquerChargement() {

		ExtElement imgEl = Ext.get(imageConteneur.getElement());

		if(imgEl != null) {

			imgEl.unmask();

		}

	}

	/**

	 * Ajoute les listeners pour la gestions d'évènement

	 */

	public void ajouterListeners() {

		image.addClickHandler(new ClickHandler() {

			public void onClick(ClickEvent event) {

				if(!scroll) {

					if(enClic) {

						getIMediateur().doubleClicZoomImage();

					} else {

						Timer t = new Timer() {

							public void run() {

								enClic = false;

							}

						};

						enClic = true;

						t.schedule(800);

					}

				}

			}

		});

		image.addLoadHandler(new LoadHandler() {

			public void onLoad(LoadEvent event) {

				verifierEtRetaillerImage();

				Ext.get(image.getElement()).center(imageConteneur.getElement());

				demasquerChargement();

			}

		});

		image.addMouseWheelHandler(new MouseWheelHandler() {

			public void onMouseWheel(MouseWheelEvent event) {

				if(event.isNorth()) {

					masquerChargement();

					getIMediateur().clicBoutonZoomImage("suiv");

				} else {

					masquerChargement();

					getIMediateur().clicBoutonZoomImage("prev");

				}

			}

		});

		// gestion du clic sur le bouton précedent

		prev.addClickHandler(new ClickHandler() {

			// en cas de clic

			public void onClick(ClickEvent event) {

				// on notifie le médiateur

				masquerChargement();

				getIMediateur().clicBoutonZoomImage("prev");

			}

		});

		// gestion du clic sur le bouton suivant

		suiv.addClickHandler(new ClickHandler() {

			// en cas de clic

			public void onClick(ClickEvent event) {

				// on notifie le médiateur

				masquerChargement();

				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 modifie enfin la taille de l'image pour qu'elle soit affichée

		int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());

		int[] tailleImage = new int[2];

		if(Ext.isIE()) {

			image.setHeight(calculerDimensions(getTailleImage(),max,max)[1]+"px");

			image.setWidth(calculerDimensions(getTailleImage(),max,max)[0]+"px");

		} else {

			if(max == imageConteneur.getHeight()) {

				tailleImage[0] = getTailleImage()[0];

				tailleImage[1] = max;

				image.setHeight(max+"px");

			} else {

				tailleImage[1] = getTailleImage()[0];

				tailleImage[0] = max;

				image.setWidth(max+"px");

			}

		}

	}

	public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) {

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

        float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ;

        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 = {(int)Math.round(XYresize[0]),(int) Math.round(XYresize[1])} ;

        return res;

    }

	public void configDragAndDrop()

	{

		// on fabrique la nouvelle configuration

		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup

		DropTargetConfig dtc = new DropTargetConfig();

		dtc.setdDdGroup("DragGroupName");

		//La drop target permet de gérer l'évenement onDrop sur l'élement courant

		@SuppressWarnings("unused")

		DropTarget tg = new DropTarget(this, dtc)

		{

			public boolean notifyDrop(DragSource source, EventObject e, DragData data){

				// si on reçoit des données provenant d'une grille

				if(data instanceof GridDragData)

		    	  {

		    		  		// on appelle le médiateur

		    		  		return iMediateur.lierObsDD(source, e, data,getId()) ;

		    	  }

				return false ;

			}

			public String notifyOver(DragSource source, EventObject e, DragData data){

			    return "x-dd-drop-ok";

			}

		};

	}

	/**

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

	}

	/**

	 * Acesseurs pour l'identifiant de l'image

	 * @return l'id de l'image

	 */

	public String getIdImage()

	{

		return idImage ;

	}

	/**

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

	}

	public void setInfosTaxon(String nomTaxon) {

		if(nomTaxon != null && !nomTaxon.equals("")) {

			nomTaxon = getNomsObservationsFormatees(nomTaxon);

		}

		infosTaxon.setHtml("<div id='infos_taxon'><span class='texte_info_taxon'>"+nomTaxon+"</span></div>");

		infosTaxon.doLayout();

	}

	/**

	 * 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 boolean estPortrait() {

		return imageHeight > imageWidth;

	}

	public boolean estPaysage() {

		return !estPortrait();

	}

	/**

	 * Accesseur pour le conteneur de l'image

	 * @return le conteur de l'image

	 */

	public Panel getImageConteneur() {

		return imageConteneur;

	}

	private String getNomsObservationsFormatees(String nomObs) {

		String htmlInfobulle = "";

		String[][] obs = getObservationsAssociees(nomObs);

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

			if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) {

				htmlInfobulle += ", "+obs[i][1];

			}

		}

		htmlInfobulle = htmlInfobulle.replaceFirst(", ", "");

		return htmlInfobulle;

	}

	private String[][] getObservationsAssociees(String nomObs) {

		if(nomObs.trim().equals("")) {

			return new String[0][0];

		}

		String[] obsTab = nomObs.split(";;");

		String[][] obsAnalysees = new String[obsTab.length][3];

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

			obsAnalysees[i] = obsTab[i].split("#");

		}

		return obsAnalysees;

	}

	private boolean[] estAssocieeTransmise(String nomObs) {

		String[][] obs = getObservationsAssociees(nomObs);

		boolean[] associeesTranmises = {false, false};

		if(obs.length > 0) {

			associeesTranmises[0] = true;

		}

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

			if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) {

				associeesTranmises[1] = true;

			}

		}

		return associeesTranmises;

	}

}