Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 jpm 1
package org.tela_botanica.client.vues;
2
 
3
import org.tela_botanica.client.image.ImageMediateur;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
104 jpm 5
import org.tela_botanica.client.modeles.Configuration;
94 jpm 6
import org.tela_botanica.client.observation.ObservationMediateur;
7
 
8
import com.google.gwt.user.client.DOM;
9
import com.google.gwt.user.client.Event;
10
import com.google.gwt.user.client.Window;
11
import com.google.gwt.user.client.ui.ClickListener;
12
import com.google.gwt.user.client.ui.Image;
104 jpm 13
import com.google.gwt.user.client.ui.MenuItem;
94 jpm 14
import com.google.gwt.user.client.ui.Widget;
15
import com.gwtext.client.core.EventObject;
16
import com.gwtext.client.core.RegionPosition;
17
import com.gwtext.client.dd.DragData;
18
import com.gwtext.client.dd.DragSource;
19
import com.gwtext.client.dd.DropTarget;
20
import com.gwtext.client.dd.DropTargetConfig;
130 aurelien 21
import com.gwtext.client.widgets.BoxComponent;
22
import com.gwtext.client.widgets.Component;
94 jpm 23
import com.gwtext.client.widgets.Container;
24
import com.gwtext.client.widgets.Panel;
130 aurelien 25
import com.gwtext.client.widgets.event.PanelListener;
94 jpm 26
import com.gwtext.client.widgets.event.PanelListenerAdapter;
27
import com.gwtext.client.widgets.grid.GridDragData;
28
import com.gwtext.client.widgets.layout.BorderLayout;
29
import com.gwtext.client.widgets.layout.BorderLayoutData;
104 jpm 30
import com.gwtext.client.widgets.menu.BaseItem;
31
import com.gwtext.client.widgets.menu.Item;
32
import com.gwtext.client.widgets.menu.Menu;
33
import com.gwtext.client.widgets.menu.event.MenuListener;
34
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
94 jpm 35
 
36
/**
37
 * Panneau d'affichage d'une image avec des boutons précdents et suivant
38
 *
39
 * @author aurelien
40
 *
41
 */
42
public class MiniZoomImageVue extends Panel implements Rafraichissable {
43
 
44
	/**
45
	 * Le médiateur associé à la vue
46
	 */
47
	private ObservationMediateur oMediateur = null;
48
 
49
	/**
50
	 * Panneau conteneur pour l'image
51
	 */
52
	private Panel imageConteneur = null;
53
	/**
54
	 * l'image à afficher
55
	 */
97 jpm 56
	private Image image = new Image("");
94 jpm 57
	/**
58
	 * Bouton précédent
59
	 */
60
	private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
61
	/**
62
	 * Bouton suivant
63
	 */
64
	private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
65
 
66
	/**
67
	 * Taille originale Y de l'image
68
	 */
69
	private int imageHeight = 0;
70
 
71
	/**
72
	 * Taille originale X de l'image
73
	 */
74
	private int imageWidth = 0;
75
 
76
	/**
77
	 * Identifiant de l'image
78
	 */
79
	private String idImage = "0" ;
80
 
81
	private String[] infosImages = null ;
82
 
83
	private int index = 0 ;
84
 
85
	/**
86
	 * Booleen d'initalisation général
87
	 */
88
	private boolean initialise = false;
89
 
90
	/**
91
	 * Booleen d'initalisation du conteneur d'image
92
	 */
93
	private boolean conteneurInitialise = false;
94
 
95
	/**
96
	 * Constructeur sans argument (privé car ne doit être utilisé)
97
	 */
98
	@SuppressWarnings("unused")
99
	private MiniZoomImageVue() {
100
		super();
101
	}
102
 
103
	/**
104
	 * Constructeur avec argument
105
	 *
106
	 * @param im
107
	 *            le médiateur à associer à la vue
108
	 */
109
	public MiniZoomImageVue(ObservationMediateur im) {
110
		super("Image liées");
111
		setId("x-view-mini-zoom-panel");
112
		// on associe le médiateur
113
		oMediateur = im;
114
 
115
		prev.setStylePrimaryName("x-view-zoom-button-p");
116
		suiv.setStylePrimaryName("x-view-zoom-button-s");
117
 
118
		// on crée une image qui gère le double clic et la roulette de la souris
119
		image = new Image() {
120
 
121
			public void onBrowserEvent(Event event) {
122
 
123
				// lors d'un déplacement de la roulette
124
				if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) {
125
 
126
					// on simule un clic sur le bouton précédent
127
					if (event.getMouseWheelVelocityY() >= 1) {
128
						prev.click();
129
					}
130
 
131
					// ou suivant
132
					if (event.getMouseWheelVelocityY() <= -1) {
133
						suiv.click();
134
					}
135
				}
104 jpm 136
 
137
				if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) {
138
 
139
					event.preventDefault() ;
140
					int[] xy = {event.getClientX(),event.getClientY()} ;
141
					afficherMenu(xy) ;
142
				}
94 jpm 143
			}
144
 
145
		};
146
 
130 aurelien 147
		image.setPixelSize(150, 150);
148
 
94 jpm 149
		infosImages = new String[0] ;
150
 
151
		this.setHeader(true);
152
 
153
		imageConteneur = new Panel() ;
154
		imageConteneur.setBorder(false);
155
 
156
		imageConteneur.add(image);
157
		imageConteneur.setId("x-view-mini-zoom-img");
158
 
159
		// il n'existe pas de méthode pour ajouter un listener pour le double
160
		// clic sur une image
161
		// alors on lui dit manuellement de capter l'évènement double clic
162
		image.sinkEvents(Event.ONDBLCLICK);
163
		image.sinkEvents(Event.ONMOUSEWHEEL);
104 jpm 164
		image.sinkEvents(Event.ONCONTEXTMENU) ;
94 jpm 165
 
166
		// l'image de base est vide
97 jpm 167
		image.setUrl("");
94 jpm 168
 
169
		this.setLayout(new BorderLayout());
170
 
130 aurelien 171
		prev.setWidth("15%");
172
		suiv.setWidth("15%");
94 jpm 173
 
174
		this.add(prev, new BorderLayoutData(RegionPosition.WEST));
175
		this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
176
		this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
177
 
178
		imageConteneur.setMaskDisabled(true);
179
		this.setBorder(false);
180
 
181
		conteneurInitialise = true;
182
		initialise = true;
183
 
184
		// on ajoute les listeners
185
		ajouterListeners();
186
 
187
	}
188
 
189
	/**
190
	 * Méthode héritée de l'interface rafraichissable
191
	 *
192
	 * @param nouvelleDonnees
193
	 *            les nouvelles données
194
	 * @param repandreRafraichissement
195
	 *            le booleen qui dit si on doit répnadre l'évènement
196
	 */
197
	public void rafraichir(Object nouvelleDonnees,
198
			boolean repandreRafraichissement) {
199
 
200
		// si on reçoit une string
201
		if (nouvelleDonnees instanceof String[] && initialise
140 aurelien 202
				&& conteneurInitialise && ((String[])nouvelleDonnees).length != 0) {
94 jpm 203
			infosImages = (String[]) nouvelleDonnees;
204
			index = 0 ;
205
			afficherImage() ;
206
 
207
		} else {
208
			// sinon on met une image vide
209
			infosImages = new String[0] ;
140 aurelien 210
			getImage().setUrl("ill_liaison.png");
211
			imageWidth = getImage().getWidth();
212
			imageHeight = getImage().getHeight();
213
			verifierEtRetaillerImage();
94 jpm 214
		}
215
	}
216
 
217
	public void afficherImage()
218
	{
219
		// c'est l'url de l'image qu'on associe à la vue
220
		if(infosImages.length != 0)
221
		{
97 jpm 222
			activerPanneau() ;
104 jpm 223
			getImage().setUrl(convertirIdEnUrl(infosImages[index]));
130 aurelien 224
			imageWidth =getImage().getWidth();
225
			imageHeight = getImage().getHeight();
226
			verifierEtRetaillerImage();
94 jpm 227
		}
228
		else
229
		{
97 jpm 230
			desactiverPanneau() ;
94 jpm 231
		}
232
	}
233
 
234
	/**
235
	 * Desactive visuellement le panneau et les boutons
236
	 */
237
	public void desactiverPanneau() {
97 jpm 238
		getImage().setUrl("");
94 jpm 239
		prev.setEnabled(false);
240
		suiv.setEnabled(false);
241
	}
242
 
243
	/**
244
	 * Active visuellement le panneau et les boutons
245
	 */
246
	public void activerPanneau() {
247
		prev.setEnabled(true);
248
		suiv.setEnabled(true);
249
	}
250
 
251
	/**
252
	 * Ajoute les listeners pour la gestions d'évènement
253
	 */
254
	public void ajouterListeners() {
255
 
256
		// gestion du clic sur le bouton précedent
257
		prev.addClickListener(new ClickListener() {
258
 
259
			// en cas de clic
260
			public void onClick(Widget sender) {
261
 
262
				if(infosImages.length != 0) {
263
					if(index == 0)
264
					{
265
						index = infosImages.length - 1 ;
266
					}
267
					else
268
					{
269
						index-- ;
270
					}
271
 
272
					afficherImage() ;
273
				}
274
			}
275
 
276
		});
277
 
278
		// gestion du clic sur le bouton suivant
279
		suiv.addClickListener(new ClickListener() {
280
 
281
			// en cas de clic
282
			public void onClick(Widget sender) {
283
 
284
				if(infosImages.length != 0) {
285
					if(index == infosImages.length - 1)
286
					{
287
						index = 0 ;
288
					}
289
					else
290
					{
291
						index++ ;
292
					}
293
 
294
					afficherImage() ;
295
				}
296
 
297
			}
298
 
299
		});
130 aurelien 300
 
94 jpm 301
	}
302
 
303
	/**
304
	 * Accesseur pour le médiateur
305
	 *
306
	 * @return le médiateur associé à la vue
307
	 */
308
	public ObservationMediateur getIMediateur() {
309
		return oMediateur;
310
	}
311
 
312
	/**
313
	 * Accesseur au conteneur de l'image
314
	 *
315
	 * @return le conteneur de l'image
316
	 */
317
	public Image getImage() {
318
		return image;
319
	}
320
 
321
	/**
322
	 * Acesseurs pour l'identifiant de l'image
323
	 * @return l'id de l'image
324
	 */
325
	public String getIdImage()
326
	{
104 jpm 327
		return infosImages[index] ;
94 jpm 328
	}
329
 
330
	/**
331
	 * Accesseur pour le bouton précédent
332
	 *
333
	 * @return le bouton précédent
334
	 */
335
	public com.google.gwt.user.client.ui.Button getPrev() {
336
		return prev;
337
	}
338
 
339
	/**
340
	 * Accesseur pour le bouton suivant
341
	 *
342
	 * @return le bouton suivant
343
	 */
344
	public com.google.gwt.user.client.ui.Button getSuiv() {
345
		return suiv;
346
	}
347
 
348
	/**
349
	 * Setter pour la taille de l'image
350
	 *
351
	 * @param x
352
	 *            la largeur en pixels
353
	 * @param y
354
	 *            la hauteur en pixels
355
	 */
356
	public void setTailleImage(int x, int y) {
357
		imageHeight = y;
358
		imageWidth = x;
359
	}
360
 
361
	/**
362
	 * Setteur pour l'identifiant de l'image
363
	 * @param id le nouvel identifiant
364
	 */
365
	public void setIdImage(String id)
366
	{
367
		idImage = id ;
368
	}
369
 
370
	/**
371
	 * renvoie la taille originale de l'image
372
	 *
373
	 * @return un tableau de deux entiers contenant la largeur puis la hauteur
374
	 */
375
	public int[] getTailleImage() {
376
		int[] taille = { imageHeight, imageWidth };
377
 
378
		return taille;
379
	}
380
 
381
	/**
382
	 * Accesseur pour le conteneur de l'image
383
	 * @return le conteur de l'image
384
	 */
385
	public Panel getImageConteneur() {
386
 
387
		return imageConteneur;
388
 
389
	}
104 jpm 390
 
391
	public void raz() {
392
 
393
		infosImages = new String[0] ;
394
		getImage().setUrl("");
395
 
396
	}
397
 
398
	public void supprimerLiaisonImage() {
399
 
400
		if(infosImages.length > 0) {
401
 
402
			getImage().setUrl("") ;
403
			int nouvelleTaille = infosImages.length - 1 ;
404
			int indexSupp = index ;
405
 
406
			String[] nouveauInfosImages = new String[nouvelleTaille] ;
407
			int j = 0 ;
408
 
409
			for(int i = 0 ; i < infosImages.length ; i++) {
410
 
411
				if(i != indexSupp) {
412
 
413
					nouveauInfosImages[j] = infosImages[i] ;
414
					j++ ;
415
				}
416
			}
417
 
418
			infosImages = nouveauInfosImages ;
419
			index = 0 ;
420
 
421
			afficherImage() ;
422
		}
423
	}
424
 
425
	public void afficherMenu(int[] xy) {
426
 
427
		Menu mn = new Menu() ;
428
		final Item suppLiaison = new Item("Supprimer la liaison") ;
429
 
430
		mn.addItem(suppLiaison) ;
431
 
432
		mn.addListener(new MenuListenerAdapter() {
433
 
434
			public void onItemClick(BaseItem item, EventObject e) {
435
 
436
				// si c'est l'aide
437
				if (item.equals(suppLiaison)) {
438
					// on notifie le médiateur
439
					getIMediateur().supprimerLiaisonObsImage() ;
440
				}
441
			}
442
 
443
		}) ;
444
 
445
		mn.showAt(xy) ;
446
	}
447
 
448
	public String convertirIdEnUrl(String idImg)
449
	{
450
		int maxZeros = 9 - idImg.length();
451
 
452
		for (int j = 0; j < maxZeros; j++) {
453
			idImg = "0" + idImg;
454
		}
455
 
456
		String baseUrl = Configuration.getImageBaseUrl() ;
457
 
458
		String dossierNv1 = idImg.substring(0, 3);
459
		String dossierNv2 = idImg.substring(3, 6);
460
		String fichierNv = idImg.substring(6, 9);
461
 
462
		String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv;
463
 
464
		String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 };
465
 
466
		String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/"
467
		+ infosFichier[0] + "_M.jpg";
468
 
469
		return urlImg ;
470
	}
130 aurelien 471
 
472
	/**
473
	 * Verifie si l'image est plus grande que le conteneur et la retaille le cas
474
	 * echeant
475
	 */
476
	public void verifierEtRetaillerImage() {
477
		// si l'image est nulle
478
		if (image == null) {
479
			// on ne fait rien
480
			return;
481
		}
145 aurelien 482
		/*
130 aurelien 483
		// on prend la taille originale de l'image
484
		int originalX = getTailleImage()[0];
485
		int originalY = getTailleImage()[1];
486
 
487
		// on la transforme en float (la division entre entier donne de curieux
488
		// résultats)
489
		float fOriginalX = (new Float(originalX)).floatValue();
490
		float fOriginalY = (new Float(originalY)).floatValue();
491
 
492
		// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
493
		float rapportTaille = fOriginalX / fOriginalY;
494
 
495
		// la nouvelle taille est pour le moment égale à l'ancienne
496
		int nouvelleTailleX = originalX;
497
		int nouvelleTailleY = originalY;
498
 
499
		// on prend la taille du conteneur
500
		int tailleConteneurX = imageConteneur.getWidth();
501
		int tailleConteneurY = imageConteneur.getHeight();
502
 
503
		int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY);
504
		int max = Math.min(maxConteneur, 300);
505
 
506
		// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
507
		// grande)
508
		// si la longueur de l'image est la plus grande des deux
509
 
510
			int maxImage = Math.max(originalX, originalY);
511
 
512
			if(maxImage == originalX) {
513
				// on prend la longueur comme taille de référence, qu'on met à
514
				// la longueur du conteneur
515
				nouvelleTailleX = max;
516
				// et on recalcule la hauteur, par rapport à la nouvelle
517
				// longueur, en gardant le format de 'limage
518
				nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
519
						/ rapportTaille);
520
			}
521
			else
522
			{
523
				// si la hauteur est la plus grande, on fait le même genre
524
				// d'opération en prenant la hauteur comme référence
525
				nouvelleTailleY = max;
526
				nouvelleTailleX = (int) Math.floor(nouvelleTailleY
527
						* rapportTaille);
528
			}
145 aurelien 529
		*/
130 aurelien 530
		// on modifie enfin la taille de l'image pour qu'elle soit affichée
145 aurelien 531
		int[] dim = calculerDimensions(getTailleImage());
532
		getImage().setSize("" + dim[0] + "px",
533
				"" + dim[1] + "px");
130 aurelien 534
 
145 aurelien 535
 
130 aurelien 536
		doLayout();
537
	}
145 aurelien 538
 
539
	public int[] calculerDimensions(int[] tailleXY) {
540
 
541
		float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
542
        float tailleOr = Math.min(300,imageConteneur.getWidth()) ;
543
        float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
544
        float[] XYresize = new float[2];
545
 
546
        if(maxTaille == tailleXY[0]) {
547
            float rapport = tailleXYf[1]/tailleXYf[0] ;
548
            XYresize[0] = tailleOr ;
549
            XYresize[1] = tailleOr*rapport ;
550
        }else {
551
            float rapport = tailleXYf[0]/tailleXYf[1] ;
552
            XYresize[1] = tailleOr ;
553
            XYresize[0] = tailleOr*rapport ;
554
        }
555
 
556
        int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
557
 
558
        return res;
559
    }
94 jpm 560
}
561