Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 aperonnet 1
package org.tela_botanica.client.vues;
2
 
3
import org.tela_botanica.client.image.ImageMediateur;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
5
 
6
import com.google.gwt.user.client.DOM;
7
import com.google.gwt.user.client.Event;
8
import com.google.gwt.user.client.ui.ClickListener;
9
import com.google.gwt.user.client.ui.Image;
10
import com.google.gwt.user.client.ui.Widget;
5 aperonnet 11
import com.gwtext.client.core.EventObject;
2 aperonnet 12
import com.gwtext.client.core.RegionPosition;
5 aperonnet 13
import com.gwtext.client.dd.DragData;
14
import com.gwtext.client.dd.DragSource;
15
import com.gwtext.client.dd.DropTarget;
16
import com.gwtext.client.dd.DropTargetConfig;
2 aperonnet 17
import com.gwtext.client.widgets.Container;
18
import com.gwtext.client.widgets.Panel;
19
import com.gwtext.client.widgets.event.PanelListenerAdapter;
5 aperonnet 20
import com.gwtext.client.widgets.grid.GridDragData;
2 aperonnet 21
import com.gwtext.client.widgets.layout.BorderLayout;
22
import com.gwtext.client.widgets.layout.BorderLayoutData;
23
 
24
/**
25
 * Panneau d'affichage d'une image avec des boutons précdents et suivant
5 aperonnet 26
 *
2 aperonnet 27
 * @author aurelien
5 aperonnet 28
 *
2 aperonnet 29
 */
30
public class ZoomImageVue extends Panel implements Rafraichissable {
5 aperonnet 31
 
2 aperonnet 32
	/**
33
	 * Le médiateur associé à la vue
34
	 */
5 aperonnet 35
	private ImageMediateur iMediateur = null;
36
 
2 aperonnet 37
	/**
38
	 * Panneau conteneur pour l'image
39
	 */
5 aperonnet 40
	private Panel imageConteneur = null;
2 aperonnet 41
	/**
42
	 * l'image à afficher
43
	 */
5 aperonnet 44
	private Image image = new Image("vide.jpg");
2 aperonnet 45
	/**
46
	 * Bouton précédent
47
	 */
48
	private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
49
	/**
50
	 * Bouton suivant
51
	 */
52
	private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
5 aperonnet 53
 
2 aperonnet 54
	/**
55
	 * Taille originale Y de l'image
56
	 */
5 aperonnet 57
	private int imageHeight = 0;
58
 
2 aperonnet 59
	/**
60
	 * Taille originale X de l'image
61
	 */
5 aperonnet 62
	private int imageWidth = 0;
2 aperonnet 63
 
64
	/**
5 aperonnet 65
	 * Identifiant de l'image
66
	 */
67
	private String idImage = "0" ;
68
 
69
	/**
2 aperonnet 70
	 * Booleen d'initalisation général
71
	 */
5 aperonnet 72
	private boolean initialise = false;
73
 
2 aperonnet 74
	/**
75
	 * Booleen d'initalisation du conteneur d'image
76
	 */
5 aperonnet 77
	private boolean conteneurInitialise = false;
78
 
2 aperonnet 79
	/**
80
	 * Constructeur sans argument (privé car ne doit être utilisé)
81
	 */
82
	@SuppressWarnings("unused")
5 aperonnet 83
	private ZoomImageVue() {
84
		super();
2 aperonnet 85
	}
5 aperonnet 86
 
2 aperonnet 87
	/**
88
	 * Constructeur avec argument
5 aperonnet 89
	 *
90
	 * @param im
91
	 *            le médiateur à associer à la vue
2 aperonnet 92
	 */
5 aperonnet 93
	public ZoomImageVue(ImageMediateur im) {
2 aperonnet 94
		super("Zoom");
5 aperonnet 95
		setId("x-view-zoom-panel");
2 aperonnet 96
		// on associe le médiateur
5 aperonnet 97
		iMediateur = im;
2 aperonnet 98
 
5 aperonnet 99
		prev.setStylePrimaryName("x-view-zoom-button-p");
100
		suiv.setStylePrimaryName("x-view-zoom-button-s");
101
 
2 aperonnet 102
		// on crée une image qui gère le double clic et la roulette de la souris
103
		image = new Image() {
5 aperonnet 104
 
2 aperonnet 105
			public void onBrowserEvent(Event event) {
5 aperonnet 106
 
2 aperonnet 107
				// lors du double clic
108
				if (Event.ONDBLCLICK == DOM.eventGetType(event)) {
109
 
110
					// on notifie le médiateur
111
					getIMediateur().doubleClicZoomImage();
112
				}
5 aperonnet 113
 
2 aperonnet 114
				// lors d'un déplacement de la roulette
115
				if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
116
 
117
					// on simule un clic sur le bouton précédent
5 aperonnet 118
					if (event.getMouseWheelVelocityY() >= 1) {
119
						prev.click();
2 aperonnet 120
					}
5 aperonnet 121
 
2 aperonnet 122
					// ou suivant
5 aperonnet 123
					if (event.getMouseWheelVelocityY() <= -1) {
124
						suiv.click();
2 aperonnet 125
					}
126
				}
127
			}
5 aperonnet 128
 
2 aperonnet 129
		};
5 aperonnet 130
 
131
		this.setHeader(false);
132
 
133
		imageConteneur = new Panel() ;
2 aperonnet 134
		imageConteneur.setBorder(false);
5 aperonnet 135
 
136
		imageConteneur.add(image);
137
		imageConteneur.setId("x-view-zoom-img");
138
 
139
		// il n'existe pas de méthode pour ajouter un listener pour le double
140
		// clic sur une image
2 aperonnet 141
		// alors on lui dit manuellement de capter l'évènement double clic
142
		image.sinkEvents(Event.ONDBLCLICK);
5 aperonnet 143
		image.sinkEvents(Event.ONMOUSEWHEEL);
144
 
2 aperonnet 145
		// l'image de base est vide
146
		image.setUrl("vide.jpg");
5 aperonnet 147
 
2 aperonnet 148
		this.setLayout(new BorderLayout());
5 aperonnet 149
 
2 aperonnet 150
		prev.setWidth("60px");
151
		suiv.setWidth("60px");
5 aperonnet 152
 
153
		this.add(prev, new BorderLayoutData(RegionPosition.WEST));
154
		this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
155
		this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
156
 
157
		imageConteneur.setMaskDisabled(true);
2 aperonnet 158
		this.setBorder(false);
5 aperonnet 159
 
160
		conteneurInitialise = true;
161
		initialise = true;
2 aperonnet 162
 
5 aperonnet 163
		configDragAndDrop() ;
164
 
2 aperonnet 165
		// on ajoute les listeners
166
		ajouterListeners();
167
 
168
	}
169
 
170
	/**
171
	 * Méthode héritée de l'interface rafraichissable
5 aperonnet 172
	 *
173
	 * @param nouvelleDonnees
174
	 *            les nouvelles données
175
	 * @param repandreRafraichissement
176
	 *            le booleen qui dit si on doit répnadre l'évènement
2 aperonnet 177
	 */
5 aperonnet 178
	public void rafraichir(Object nouvelleDonnees,
179
			boolean repandreRafraichissement) {
180
 
2 aperonnet 181
		// si on reçoit une string
5 aperonnet 182
		if (nouvelleDonnees instanceof String[] && initialise
183
				&& conteneurInitialise) {
184
			String[] infos = (String[]) nouvelleDonnees;
2 aperonnet 185
			// c'est l'url de l'image qu'on associe à la vue
5 aperonnet 186
			if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
187
				getImage().setUrl(infos[0]);
188
				int x = Integer.parseInt(infos[1]);
189
				int y = Integer.parseInt(infos[2]);
190
 
191
				setTailleImage(x, y);
2 aperonnet 192
 
5 aperonnet 193
				setIdImage(infos[3]) ;
194
 
195
				verifierEtRetaillerImage();
2 aperonnet 196
			}
5 aperonnet 197
		} else {
2 aperonnet 198
			// sinon on met une image vide
5 aperonnet 199
			getImage().setUrl("vide.jpeg");
2 aperonnet 200
		}
201
	}
5 aperonnet 202
 
2 aperonnet 203
	/**
204
	 * Desactive visuellement le panneau et les boutons
205
	 */
5 aperonnet 206
	public void desactiverPanneau() {
207
		getImage().setUrl("vide.jpeg");
208
		prev.setEnabled(false);
2 aperonnet 209
		suiv.setEnabled(false);
210
	}
5 aperonnet 211
 
2 aperonnet 212
	/**
213
	 * Active visuellement le panneau et les boutons
214
	 */
5 aperonnet 215
	public void activerPanneau() {
2 aperonnet 216
		prev.setEnabled(true);
217
		suiv.setEnabled(true);
218
	}
5 aperonnet 219
 
2 aperonnet 220
	/**
221
	 * Ajoute les listeners pour la gestions d'évènement
222
	 */
5 aperonnet 223
	public void ajouterListeners() {
224
 
2 aperonnet 225
		// gestion du clic sur le bouton précedent
226
		prev.addClickListener(new ClickListener() {
227
 
228
			// en cas de clic
229
			public void onClick(Widget sender) {
230
				// on notifie le médiateur
231
				getIMediateur().clicBoutonZoomImage("prev");
232
			}
5 aperonnet 233
 
2 aperonnet 234
		});
5 aperonnet 235
 
2 aperonnet 236
		// gestion du clic sur le bouton suivant
237
		suiv.addClickListener(new ClickListener() {
238
 
239
			// en cas de clic
240
			public void onClick(Widget sender) {
5 aperonnet 241
				// on notifie le médiateur
2 aperonnet 242
				getIMediateur().clicBoutonZoomImage("suiv");
243
			}
5 aperonnet 244
 
2 aperonnet 245
		});
5 aperonnet 246
 
2 aperonnet 247
		// gestion du redimensionnement
248
		this.addListener(new PanelListenerAdapter() {
5 aperonnet 249
 
2 aperonnet 250
			// lors d'un redimensionnement de l'application
5 aperonnet 251
 
252
			public void onBodyResize(Panel panel, java.lang.String width,
253
					java.lang.String height) {
2 aperonnet 254
				// on vérifie et on retaille l'image
5 aperonnet 255
				verifierEtRetaillerImage();
2 aperonnet 256
			}
5 aperonnet 257
		});
258
 
2 aperonnet 259
		// gestion du redimensionnement lors de l'affichage du conteneur
260
		imageConteneur.addListener(new PanelListenerAdapter() {
5 aperonnet 261
 
2 aperonnet 262
			// avant de finir d'afficher
5 aperonnet 263
 
264
			public void onAfterLayout(Container self) {
2 aperonnet 265
				// on redimensionne
5 aperonnet 266
				verifierEtRetaillerImage();
2 aperonnet 267
			}
5 aperonnet 268
		});
269
 
2 aperonnet 270
	}
271
 
272
	/**
5 aperonnet 273
	 * Verifie si l'image est plus grande que le conteneur et la retaille le cas
274
	 * echeant
2 aperonnet 275
	 */
5 aperonnet 276
	public void verifierEtRetaillerImage() {
2 aperonnet 277
		// si l'image est nulle
5 aperonnet 278
		if (image == null) {
2 aperonnet 279
			// on ne fait rien
5 aperonnet 280
			return;
281
		}
282
 
2 aperonnet 283
		// on prend la taille originale de l'image
5 aperonnet 284
		int originalX = getTailleImage()[0];
285
		int originalY = getTailleImage()[1];
286
 
287
		// on la transforme en float (la division entre entier donne de curieux
288
		// résultats)
289
		float fOriginalX = (new Float(originalX)).floatValue();
290
		float fOriginalY = (new Float(originalY)).floatValue();
291
 
2 aperonnet 292
		// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
5 aperonnet 293
		float rapportTaille = fOriginalX / fOriginalY;
294
 
2 aperonnet 295
		// la nouvelle taille est pour le moment égale à l'ancienne
5 aperonnet 296
		int nouvelleTailleX = originalX;
297
		int nouvelleTailleY = originalY;
298
 
2 aperonnet 299
		// on prend la taille du conteneur
5 aperonnet 300
		int tailleConteneurX = imageConteneur.getWidth();
301
		int tailleConteneurY = imageConteneur.getHeight();
302
 
2 aperonnet 303
		// si celle-ci est égale à 0 (conteneur mal initialisé)
5 aperonnet 304
		/*
305
		 * if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
306
		 * essaie de la calculer en fonction de la taille du parent et des
307
		 * frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
308
		 * this.getWidth() - prev.getOffsetWidth() * 2 ;
309
		 *  }
310
		 */
311
 
312
		// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
313
		// grande)
314
		if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
2 aperonnet 315
			// si la longueur de l'image est la plus grande des deux
5 aperonnet 316
			if (originalX > originalY) {
317
				// on prend la longueur comme taille de référence, qu'on met à
318
				// la longueur du conteneur
319
				nouvelleTailleX = tailleConteneurX;
320
				// et on recalcule la hauteur, par rapport à la nouvelle
321
				// longueur, en gardant le format de 'limage
322
				nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
323
						/ rapportTaille);
324
			} else {
325
				// si la hauteur est la plus grande, on fait le même genre
326
				// d'opération en prenant la hauteur comme référence
327
				nouvelleTailleY = tailleConteneurY;
328
				nouvelleTailleX = (int) Math.floor(nouvelleTailleY
329
						* rapportTaille);
2 aperonnet 330
			}
331
		}
5 aperonnet 332
 
2 aperonnet 333
		// on modifie enfin la taille de l'image pour qu'elle soit affichée
5 aperonnet 334
		getImage().setSize("" + nouvelleTailleX + "px",
335
				"" + nouvelleTailleY + "px");
2 aperonnet 336
	}
5 aperonnet 337
 
338
	public void configDragAndDrop()
339
	{
2 aperonnet 340
 
5 aperonnet 341
		// on fabrique la nouvelle configuration
342
		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
343
		DropTargetConfig dtc = new DropTargetConfig();
344
		dtc.setdDdGroup("DragGroupName");
345
 
346
		//La drop target permet de gérer l'évenement onDrop sur l'élement courant
347
		@SuppressWarnings("unused")
348
		DropTarget tg = new DropTarget(this, dtc)
349
		{
350
			public boolean notifyDrop(DragSource source, EventObject e, DragData data){
351
 
352
				// si on reçoit des données provenant d'une grille
353
				if(data instanceof GridDragData)
354
		    	  {
355
		    		  		// on appelle le médiateur
356
		    		  		return iMediateur.lierObsDD(source, e, data,getId()) ;
357
		    	  }
358
				return false ;
359
			}
360
 
361
			public String notifyOver(DragSource source, EventObject e, DragData data){
362
			    return "x-dd-drop-ok";
363
			}
364
		};
365
 
366
	}
367
 
2 aperonnet 368
	/**
369
	 * Accesseur pour le médiateur
5 aperonnet 370
	 *
2 aperonnet 371
	 * @return le médiateur associé à la vue
372
	 */
373
	public ImageMediateur getIMediateur() {
374
		return iMediateur;
375
	}
376
 
377
	/**
378
	 * Accesseur au conteneur de l'image
5 aperonnet 379
	 *
2 aperonnet 380
	 * @return le conteneur de l'image
381
	 */
382
	public Image getImage() {
383
		return image;
384
	}
5 aperonnet 385
 
386
	/**
387
	 * Acesseurs pour l'identifiant de l'image
388
	 * @return l'id de l'image
389
	 */
390
	public String getIdImage()
391
	{
392
		return idImage ;
393
	}
2 aperonnet 394
 
395
	/**
396
	 * Accesseur pour le bouton précédent
5 aperonnet 397
	 *
2 aperonnet 398
	 * @return le bouton précédent
399
	 */
400
	public com.google.gwt.user.client.ui.Button getPrev() {
401
		return prev;
402
	}
403
 
404
	/**
405
	 * Accesseur pour le bouton suivant
5 aperonnet 406
	 *
2 aperonnet 407
	 * @return le bouton suivant
408
	 */
409
	public com.google.gwt.user.client.ui.Button getSuiv() {
410
		return suiv;
411
	}
5 aperonnet 412
 
2 aperonnet 413
	/**
414
	 * Setter pour la taille de l'image
5 aperonnet 415
	 *
7 aperonnet 416
	 * @param x
5 aperonnet 417
	 *            la largeur en pixels
7 aperonnet 418
	 * @param y
5 aperonnet 419
	 *            la hauteur en pixels
2 aperonnet 420
	 */
5 aperonnet 421
	public void setTailleImage(int x, int y) {
422
		imageHeight = y;
423
		imageWidth = x;
2 aperonnet 424
	}
425
 
426
	/**
5 aperonnet 427
	 * Setteur pour l'identifiant de l'image
428
	 * @param id le nouvel identifiant
429
	 */
430
	public void setIdImage(String id)
431
	{
432
		idImage = id ;
433
	}
434
 
435
	/**
2 aperonnet 436
	 * renvoie la taille originale de l'image
5 aperonnet 437
	 *
2 aperonnet 438
	 * @return un tableau de deux entiers contenant la largeur puis la hauteur
439
	 */
5 aperonnet 440
	public int[] getTailleImage() {
441
		int[] taille = { imageHeight, imageWidth };
442
 
443
		return taille;
2 aperonnet 444
	}
5 aperonnet 445
 
446
	/**
447
	 * Accesseur pour le conteneur de l'image
448
	 * @return le conteur de l'image
449
	 */
450
	public Panel getImageConteneur() {
2 aperonnet 451
 
5 aperonnet 452
		return imageConteneur;
453
 
2 aperonnet 454
	}
455
}