WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/ZoomImageVue.java

 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.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.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 ;
+	private ImageMediateur iMediateur = null;
 	/**
 	 * Panneau conteneur pour l'image
 	 */
-	private Panel imageConteneur = null ;
+	private Panel imageConteneur = null;
 	/**
 	 * l'image à afficher
 	 */
-	private Image image = new Image("vide.jpg") ;
+	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 ;
+	private int imageHeight = 0;
 	/**
 	 * Taille originale X de l'image
 	 */
-	private int imageWidth = 0 ;
+	private int imageWidth = 0;
+	/**
+	 * Identifiant de l'image
+	 */
+	private String idImage = "0" ;
 	/**
 	 * Booleen d'initalisation général
 	 */
-	private boolean initialise = false ;
+	private boolean initialise = false;
 	/**
 	 * Booleen d'initalisation du conteneur d'image
 	 */
-	private boolean conteneurInitialise = false ;
+	private boolean conteneurInitialise = false;
 	/**
 	 * Constructeur sans argument (privé car ne doit être utilisé)
 	 */
 	@SuppressWarnings("unused")
-	private ZoomImageVue()
+	private ZoomImageVue() {
-	{
-		super() ;
+		super();
+	}
 	/**
 	 * Constructeur avec argument
+	 *
+	 * @param im
-	 * @param im le médiateur à associer à la vue
+	 *            le médiateur à associer à la vue
 	 */
-	public ZoomImageVue(ImageMediateur im)
+	public ZoomImageVue(ImageMediateur im) {
-	{
 		super("Zoom");
-		setId("x-view-zoom-panel") ;
+		setId("x-view-zoom-panel");
 		// on associe le médiateur
-		iMediateur = im ;
+		iMediateur = im;
-		prev.setStylePrimaryName("x-view-zoom-button-p") ;
+		prev.setStylePrimaryName("x-view-zoom-button-p");
-		suiv.setStylePrimaryName("x-view-zoom-button-s") ;
+		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)
+					if (event.getMouseWheelVelocityY() >= 1) {
-					{
-						prev.click() ;
+						prev.click();
+					}
 					// ou suivant
-					if(event.getMouseWheelVelocityY() <= -1)
+					if (event.getMouseWheelVelocityY() <= -1) {
-					{
-						suiv.click() ;
+						suiv.click();
+					}
+				}
+			}
 		};
-		this.setHeader(false) ;
+		this.setHeader(false);
-		imageConteneur = new Panel()  ;
+		imageConteneur = new Panel() ;
 		imageConteneur.setBorder(false);
-		imageConteneur.add(image) ;
+		imageConteneur.add(image);
-		imageConteneur.setId("x-view-zoom-img") ;
+		imageConteneur.setId("x-view-zoom-img");
-		// il n'existe pas de méthode pour ajouter un listener pour le double clic sur une image
+		// 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.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(prev, new BorderLayoutData(RegionPosition.WEST));
-		this.add(imageConteneur,new BorderLayoutData(RegionPosition.CENTER));
+		this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
-		this.add(suiv,new BorderLayoutData(RegionPosition.EAST));
+		this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
-		imageConteneur.setMaskDisabled(true) ;
+		imageConteneur.setMaskDisabled(true);
 		this.setBorder(false);
+		conteneurInitialise = true;
+		initialise = true;
-		conteneurInitialise = true ;
-		initialise = true ;
+		configDragAndDrop() ;
 		// on ajoute les listeners
 		ajouterListeners();
+	}
 	/**
 	 * Méthode héritée de l'interface rafraichissable
+	 *
+	 * @param nouvelleDonnees
-	 * @param nouvelleDonnees les nouvelles données
+	 *            les nouvelles données
+	 * @param repandreRafraichissement
-	 * @param repandreRafraichissement le booleen qui dit si on doit répnadre l'évènement
+	 *            le booleen qui dit si on doit répnadre l'évènement
 	 */
-	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
+	public void rafraichir(Object nouvelleDonnees,
+			boolean repandreRafraichissement) {
 		// si on reçoit une string
-		if(nouvelleDonnees instanceof String[] && initialise && conteneurInitialise)
+		if (nouvelleDonnees instanceof String[] && initialise
-		{
+				&& conteneurInitialise) {
-			String[] infos = (String[])nouvelleDonnees ;
+			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]);
+				getImage().setUrl(infos[0]);
-			if(infos[1] != null && infos[2] != null)
-			{
-				int x = Integer.parseInt(infos[1]) ;
+				int x = Integer.parseInt(infos[1]);
-				int y = Integer.parseInt(infos[2]) ;
+				int y = Integer.parseInt(infos[2]);
-				setTailleImage(x,y) ;
+				setTailleImage(x, y);
+				setIdImage(infos[3]) ;
-				verifierEtRetaillerImage() ;
+				verifierEtRetaillerImage();
-			}
-		}
+			}
-		else
 		} else {
 			// sinon on met une image vide
-			getImage().setUrl("vide.jpeg") ;
+			getImage().setUrl("vide.jpeg");
+		}
 	}
 	/**
 	 * Desactive visuellement le panneau et les boutons
 	 */
-	public void desactiverPanneau()
+	public void desactiverPanneau() {
-	{
-		getImage().setUrl("vide.jpeg") ;
+		getImage().setUrl("vide.jpeg");
-		prev.setEnabled(false) ;
+		prev.setEnabled(false);
 		suiv.setEnabled(false);
+	}
 	/**
 	 * Active visuellement le panneau et les boutons
 	 */
-	public void activerPanneau()
+	public void activerPanneau() {
-	{
 		prev.setEnabled(true);
 		suiv.setEnabled(true);
+	}
 	/**
 	 * Ajoute les listeners pour la gestions d'évènement
 	 */
-	public void ajouterListeners()
+	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)
+			public void onBodyResize(Panel panel, java.lang.String width,
-			{
+					java.lang.String height) {
 				// on vérifie et on retaille l'image
-				verifierEtRetaillerImage() ;
+				verifierEtRetaillerImage();
+			}
-		}) ;
+		});
 		// gestion du redimensionnement lors de l'affichage du conteneur
 		imageConteneur.addListener(new PanelListenerAdapter() {
 			// avant de finir d'afficher
-			public void onAfterLayout(Container self)
+			public void onAfterLayout(Container self) {
-			{
 				// on redimensionne
-				verifierEtRetaillerImage() ;
+				verifierEtRetaillerImage();
+			}
-		}) ;
+		});
+	}
 	/**
-	 * Verifie si l'image est plus grande que le conteneur et la retaille le cas echeant
+	 * Verifie si l'image est plus grande que le conteneur et la retaille le cas
+	 * echeant
 	 */
-	public void verifierEtRetaillerImage()
+	public void verifierEtRetaillerImage() {
-	{
 		// si l'image est nulle
-		if(image == null)
+		if (image == null) {
-		{
 			// on ne fait rien
-			return ;
+			return;
 		}
 		// on prend la taille originale de l'image
-		int originalX = getTailleImage()[0] ;
+		int originalX = getTailleImage()[0];
-		int originalY = getTailleImage()[1]	;
+		int originalY = getTailleImage()[1];
-		// on la transforme en float (la division entre entier donne de curieux résultats)
+		// on la transforme en float (la division entre entier donne de curieux
+		// résultats)
-		float fOriginalX = (new Float(originalX)).floatValue() ;
+		float fOriginalX = (new Float(originalX)).floatValue();
-		float fOriginalY = (new Float(originalY)).floatValue() ;
+		float fOriginalY = (new Float(originalY)).floatValue();
 		// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
-		float rapportTaille = fOriginalX/fOriginalY ;
+		float rapportTaille = fOriginalX / fOriginalY;
 		// la nouvelle taille est pour le moment égale à l'ancienne
-		int nouvelleTailleX = originalX ;
+		int nouvelleTailleX = originalX;
-		int nouvelleTailleY = originalY ;
+		int nouvelleTailleY = originalY;
 		// on prend la taille du conteneur
-		int tailleConteneurX = imageConteneur.getWidth() ;
+		int tailleConteneurX = imageConteneur.getWidth();
-		int tailleConteneurY = imageConteneur.getHeight() ;
+		int tailleConteneurY = imageConteneur.getHeight();
 		// si celle-ci est égale à 0 (conteneur mal initialisé)
+		/*
-		/*if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0)
+		 * if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
-		{
-			// on essaie de la calculer en fonction de la taille du parent et des frères
+		 * essaie de la calculer en fonction de la taille du parent et des
-			tailleConteneurY = this.getHeight() ;
+		 * frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
-			tailleConteneurX = this.getWidth() - prev.getOffsetWidth() * 2 ;
+		 * this.getWidth() - prev.getOffsetWidth() * 2 ;
+		 *  }
-		}*/
+		 */
-		// si l'image ne rentre pas telle quelle (longueur ou hauteur trop grande)
+		// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
+		// grande)
-		if(originalY > tailleConteneurY || originalX > tailleConteneurX)
+		if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
-		{
 			// si la longueur de l'image est la plus grande des deux
-			if(originalX > originalY)
+			if (originalX > originalY) {
-			{
-				// on prend la longueur comme taille de référence, qu'on met à la longueur du conteneur
+				// on prend la longueur comme taille de référence, qu'on met à
+				// la longueur du conteneur
-				nouvelleTailleX = tailleConteneurX ;
+				nouvelleTailleX = tailleConteneurX;
-				// et on recalcule la hauteur, par rapport à la nouvelle longueur, en gardant le format de 'limage
+				// et on recalcule la hauteur, par rapport à la nouvelle
+				// longueur, en gardant le format de 'limage
-				nouvelleTailleY = (int)Math.floor(nouvelleTailleX*1/rapportTaille) ;
+				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);
+			}
-			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") ;
+		getImage().setSize("" + nouvelleTailleX + "px",
+				"" + nouvelleTailleY + "px");
+	}
+	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
-	 * @param X la largeur en pixels
+	 *            la largeur en pixels
+	 * @param Y
-	 * @param Y la hauteur en pixels
+	 *            la hauteur en pixels
 	 */
-	public void setTailleImage(int x, int y)
+	public void setTailleImage(int x, int y) {
-	{
-		imageHeight = y ;
+		imageHeight = y;
-		imageWidth = x ;
+		imageWidth = x;
+	}
 	/**
-	 * renvoie la taille originale de l'image
+	 * Setteur pour l'identifiant de l'image
-	 * @return un tableau de deux entiers contenant la largeur puis la hauteur
+	 * @param id le nouvel identifiant
 	 */
-	public int[] getTailleImage()
+	public void setIdImage(String id)
+	{
-		int[] taille = {imageHeight,imageWidth} ;
-		return taille ;
+		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 ;
+		return imageConteneur;
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/ZoomImageVue.java @ 34 – Rev 2 → 5