WebSVN – eFlore/Applications.cel – Diff – /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/ZoomImageVue.java

 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.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Timer;
-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.LoadListener;
+import com.google.gwt.user.client.ui.MouseWheelListener;
-import com.google.gwt.user.client.ui.Image;
+import com.google.gwt.user.client.ui.MouseWheelVelocity;
+import com.google.gwt.user.client.ui.Widget;
-import com.google.gwt.user.client.ui.Widget;
+import com.gwtext.client.core.AnimationConfig;
+import com.gwtext.client.core.EventObject;
+import com.gwtext.client.core.Ext;
+import com.gwtext.client.core.ExtElement;
 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.Container;
 import com.gwtext.client.widgets.Panel;
 import com.gwtext.client.widgets.ToolTip;
 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;
 /**
  * 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;
 	/**
 	 * 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>") ;
 	/**
+	 * true pour animer les transitions des animations
+	 */
+	private boolean animerTransition = false;
+	/**
+	 * duree des animation
+	 */
+	private float dureeAnimation = (float) 0.15 ;
+	/**.
+	 * boolean de gestion du double clic
+	 */
+	private boolean enClic = 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() {
+		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 = 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);
+		//imageConteneur.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;
 		configDragAndDrop() ;
 		// on ajoute les listeners
 		ajouterListeners();
 		tp.setDismissDelay(1750);
 		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) {
 		// 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]) ;
-				verifierEtRetaillerImage();
+				//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);
+	}
 	/**
 	 * Ajoute les listeners pour la gestions d'évènement
 	 */
 	public void ajouterListeners() {
+		image.addLoadListener(new LoadListener() {
+			public void onError(Widget sender) {
+				// TODO Auto-generated method stub
+			}
+			public void onLoad(Widget sender) {
+				int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());
+				int[] tailleImage = calculerDimensions(getTailleImage(), max, max);
+				ExtElement imgElement = Ext.get(image.getElement());
+				if(animerTransition) {
+					AnimationConfig a = new AnimationConfig() ;
+					a.setDuration((float) dureeAnimation);
+					imgElement.setHeight(tailleImage[1], a);
+					imgElement.setWidth(tailleImage[0], a);
+				} else {
+					imgElement.setHeight(tailleImage[1], false);
+					imgElement.setWidth(tailleImage[0], false);
+				}
+			}
+		});
+		image.addClickListener(new ClickListener() {
+			public void onClick(Widget sender) {
+				Window.alert(""+Event.getCurrentEvent().getButton());
+					if(enClic) {
+						getIMediateur().doubleClicZoomImage();
+					} else {
+						Timer t = new Timer() {
+							public void run() {
+								enClic = false;
+							}
+						};
+						enClic = true;
+						t.schedule(800);
+					}
+			}
+		});
+		image.addMouseWheelListener(new MouseWheelListener() {
+			public void onMouseWheel(Widget sender, MouseWheelVelocity velocity) {
+				if(velocity.getDeltaY() > 0) {
+					suiv.click();
+				} else {
+					prev.click();
+				}
+			}
+		});
 		// 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");
+	}
+	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 = {Math.round(XYresize[0]),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 ;
+	}
 	/**
 	 * 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;
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/branches/v1.6-croc/src/org/tela_botanica/client/vues/image/ZoomImageVue.java @ 3220 – Rev 195 → 207