Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
195 david 1
package org.tela_botanica.client.vues.image;
2 aperonnet 2
 
268 aurelien 3
 
2 aperonnet 4
import org.tela_botanica.client.image.ImageMediateur;
5
import org.tela_botanica.client.interfaces.Rafraichissable;
6
 
268 aurelien 7
import com.google.gwt.core.client.JavaScriptObject;
2 aperonnet 8
import com.google.gwt.user.client.Event;
207 aurelien 9
import com.google.gwt.user.client.Timer;
10
import com.google.gwt.user.client.Window;
2 aperonnet 11
import com.google.gwt.user.client.ui.ClickListener;
12
import com.google.gwt.user.client.ui.Image;
268 aurelien 13
import com.google.gwt.user.client.ui.KeyboardListener;
14
import com.google.gwt.user.client.ui.KeyboardListenerCollection;
207 aurelien 15
import com.google.gwt.user.client.ui.LoadListener;
268 aurelien 16
import com.google.gwt.user.client.ui.MouseListener;
207 aurelien 17
import com.google.gwt.user.client.ui.MouseWheelListener;
18
import com.google.gwt.user.client.ui.MouseWheelVelocity;
268 aurelien 19
import com.google.gwt.user.client.ui.ToggleButton;
2 aperonnet 20
import com.google.gwt.user.client.ui.Widget;
207 aurelien 21
import com.gwtext.client.core.AnimationConfig;
268 aurelien 22
import com.gwtext.client.core.Direction;
23
import com.gwtext.client.core.DomConfig;
5 aperonnet 24
import com.gwtext.client.core.EventObject;
207 aurelien 25
import com.gwtext.client.core.Ext;
26
import com.gwtext.client.core.ExtElement;
268 aurelien 27
import com.gwtext.client.core.Function;
207 aurelien 28
 
2 aperonnet 29
import com.gwtext.client.core.RegionPosition;
5 aperonnet 30
import com.gwtext.client.dd.DragData;
31
import com.gwtext.client.dd.DragSource;
32
import com.gwtext.client.dd.DropTarget;
33
import com.gwtext.client.dd.DropTargetConfig;
268 aurelien 34
import com.gwtext.client.widgets.Button;
35
import com.gwtext.client.widgets.Component;
2 aperonnet 36
import com.gwtext.client.widgets.Container;
37
import com.gwtext.client.widgets.Panel;
99 jpm 38
import com.gwtext.client.widgets.ToolTip;
268 aurelien 39
import com.gwtext.client.widgets.Toolbar;
40
import com.gwtext.client.widgets.ToolbarButton;
41
import com.gwtext.client.widgets.ToolbarTextItem;
42
import com.gwtext.client.widgets.event.ButtonListener;
43
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
2 aperonnet 44
import com.gwtext.client.widgets.event.PanelListenerAdapter;
5 aperonnet 45
import com.gwtext.client.widgets.grid.GridDragData;
2 aperonnet 46
import com.gwtext.client.widgets.layout.BorderLayout;
47
import com.gwtext.client.widgets.layout.BorderLayoutData;
268 aurelien 48
import com.gwtext.client.widgets.menu.Menu;
2 aperonnet 49
 
50
/**
51
 * Panneau d'affichage d'une image avec des boutons précdents et suivant
5 aperonnet 52
 *
2 aperonnet 53
 * @author aurelien
5 aperonnet 54
 *
2 aperonnet 55
 */
56
public class ZoomImageVue extends Panel implements Rafraichissable {
5 aperonnet 57
 
2 aperonnet 58
	/**
59
	 * Le médiateur associé à la vue
60
	 */
5 aperonnet 61
	private ImageMediateur iMediateur = null;
62
 
2 aperonnet 63
	/**
64
	 * Panneau conteneur pour l'image
65
	 */
5 aperonnet 66
	private Panel imageConteneur = null;
2 aperonnet 67
	/**
68
	 * l'image à afficher
69
	 */
5 aperonnet 70
	private Image image = new Image("vide.jpg");
2 aperonnet 71
	/**
72
	 * Bouton précédent
73
	 */
74
	private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
75
	/**
76
	 * Bouton suivant
77
	 */
78
	private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button();
5 aperonnet 79
 
2 aperonnet 80
	/**
81
	 * Taille originale Y de l'image
82
	 */
5 aperonnet 83
	private int imageHeight = 0;
84
 
2 aperonnet 85
	/**
86
	 * Taille originale X de l'image
87
	 */
5 aperonnet 88
	private int imageWidth = 0;
2 aperonnet 89
 
90
	/**
5 aperonnet 91
	 * Identifiant de l'image
92
	 */
93
	private String idImage = "0" ;
94
 
95
	/**
2 aperonnet 96
	 * Booleen d'initalisation général
97
	 */
5 aperonnet 98
	private boolean initialise = false;
99
 
2 aperonnet 100
	/**
101
	 * Booleen d'initalisation du conteneur d'image
102
	 */
5 aperonnet 103
	private boolean conteneurInitialise = false;
99 jpm 104
 
105
	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>") ;
5 aperonnet 106
 
2 aperonnet 107
	/**
207 aurelien 108
	 * true pour animer les transitions des animations
109
	 */
110
	private boolean animerTransition = false;
111
 
112
	/**
113
	 * duree des animation
114
	 */
115
	private float dureeAnimation = (float) 0.15 ;
116
 
117
	/**.
118
	 * boolean de gestion du double clic
119
	 */
120
	private boolean enClic = false;
121
 
268 aurelien 122
	private ToolbarButton modeZoom = null;
123
 
124
	private ToolbarTextItem valeurZoom = new ToolbarTextItem("x 1");
125
 
126
	private int sourisX = 0;
127
 
128
	private int sourisY = 0;
129
 
130
	private int sourisXFin = 0;
131
 
132
	private int sourisYFin = 0;
133
 
134
	private float niveauZoom = 1;
135
 
136
	private float pasZoom = new Float(0.1);
137
 
138
	private int maxZoom = 10;
139
 
140
	private float minZoom = new Float(0.5);
141
 
142
	protected boolean scroll = false;
143
 
207 aurelien 144
	/**
2 aperonnet 145
	 * Constructeur sans argument (privé car ne doit être utilisé)
146
	 */
147
	@SuppressWarnings("unused")
5 aperonnet 148
	private ZoomImageVue() {
149
		super();
2 aperonnet 150
	}
5 aperonnet 151
 
2 aperonnet 152
	/**
153
	 * Constructeur avec argument
5 aperonnet 154
	 *
155
	 * @param im
156
	 *            le médiateur à associer à la vue
2 aperonnet 157
	 */
5 aperonnet 158
	public ZoomImageVue(ImageMediateur im) {
2 aperonnet 159
		super("Zoom");
5 aperonnet 160
		setId("x-view-zoom-panel");
2 aperonnet 161
		// on associe le médiateur
5 aperonnet 162
		iMediateur = im;
2 aperonnet 163
 
5 aperonnet 164
		prev.setStylePrimaryName("x-view-zoom-button-p");
165
		suiv.setStylePrimaryName("x-view-zoom-button-s");
166
 
2 aperonnet 167
		// on crée une image qui gère le double clic et la roulette de la souris
207 aurelien 168
		image = new Image();
169
 
5 aperonnet 170
		this.setHeader(false);
171
 
207 aurelien 172
		imageConteneur = new Panel();
173
 
2 aperonnet 174
		imageConteneur.setBorder(false);
5 aperonnet 175
 
176
		imageConteneur.add(image);
177
		imageConteneur.setId("x-view-zoom-img");
178
 
179
		// il n'existe pas de méthode pour ajouter un listener pour le double
180
		// clic sur une image
2 aperonnet 181
		// alors on lui dit manuellement de capter l'évènement double clic
207 aurelien 182
		//imageConteneur.sinkEvents(Event.ONMOUSEWHEEL);
5 aperonnet 183
 
2 aperonnet 184
		// l'image de base est vide
185
		image.setUrl("vide.jpg");
5 aperonnet 186
 
2 aperonnet 187
		this.setLayout(new BorderLayout());
5 aperonnet 188
 
2 aperonnet 189
		prev.setWidth("60px");
190
		suiv.setWidth("60px");
5 aperonnet 191
 
268 aurelien 192
 
193
		modeZoom = new ToolbarButton("Mode Zoom");
194
		Toolbar tb = new Toolbar();
195
		tb.addButton(modeZoom);
196
		tb.addItem(valeurZoom);
197
 
198
		//setTopToolbar(tb);
199
 
5 aperonnet 200
		this.add(prev, new BorderLayoutData(RegionPosition.WEST));
201
		this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
202
		this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
203
 
204
		imageConteneur.setMaskDisabled(true);
2 aperonnet 205
		this.setBorder(false);
5 aperonnet 206
 
207
		conteneurInitialise = true;
208
		initialise = true;
2 aperonnet 209
 
5 aperonnet 210
		configDragAndDrop() ;
211
 
2 aperonnet 212
		// on ajoute les listeners
213
		ajouterListeners();
99 jpm 214
 
268 aurelien 215
		tp.setDismissDelay(1050);
99 jpm 216
		tp.applyTo(image.getElement()) ;
2 aperonnet 217
 
218
	}
219
 
220
	/**
221
	 * Méthode héritée de l'interface rafraichissable
5 aperonnet 222
	 *
223
	 * @param nouvelleDonnees
224
	 *            les nouvelles données
225
	 * @param repandreRafraichissement
226
	 *            le booleen qui dit si on doit répnadre l'évènement
2 aperonnet 227
	 */
5 aperonnet 228
	public void rafraichir(Object nouvelleDonnees,
229
			boolean repandreRafraichissement) {
230
 
268 aurelien 231
		//niveauZoom = 1;
2 aperonnet 232
		// si on reçoit une string
5 aperonnet 233
		if (nouvelleDonnees instanceof String[] && initialise
234
				&& conteneurInitialise) {
235
			String[] infos = (String[]) nouvelleDonnees;
2 aperonnet 236
			// c'est l'url de l'image qu'on associe à la vue
5 aperonnet 237
			if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
238
				getImage().setUrl(infos[0]);
239
				int x = Integer.parseInt(infos[1]);
240
				int y = Integer.parseInt(infos[2]);
241
 
242
				setTailleImage(x, y);
2 aperonnet 243
 
5 aperonnet 244
				setIdImage(infos[3]) ;
245
 
207 aurelien 246
				//verifierEtRetaillerImage();
2 aperonnet 247
			}
5 aperonnet 248
		} else {
2 aperonnet 249
			// sinon on met une image vide
40 david 250
			getImage().setUrl("vide.jpg");
2 aperonnet 251
		}
252
	}
5 aperonnet 253
 
2 aperonnet 254
	/**
255
	 * Desactive visuellement le panneau et les boutons
256
	 */
5 aperonnet 257
	public void desactiverPanneau() {
258
		getImage().setUrl("vide.jpeg");
259
		prev.setEnabled(false);
2 aperonnet 260
		suiv.setEnabled(false);
261
	}
5 aperonnet 262
 
2 aperonnet 263
	/**
264
	 * Active visuellement le panneau et les boutons
265
	 */
5 aperonnet 266
	public void activerPanneau() {
2 aperonnet 267
		prev.setEnabled(true);
268
		suiv.setEnabled(true);
269
	}
225 aurelien 270
 
271
	public void masquerChargement() {
272
		ExtElement imgEl = Ext.get(imageConteneur.getElement());
273
		if(imgEl != null && !imgEl.isMasked()) {
274
			imgEl.mask("Chargement");
275
		}
276
	}
277
 
278
	public void demasquerChargement() {
279
		ExtElement imgEl = Ext.get(imageConteneur.getElement());
280
		if(imgEl != null && imgEl.isMasked()) {
281
			imgEl.unmask();
282
		}
283
	}
5 aperonnet 284
 
2 aperonnet 285
	/**
286
	 * Ajoute les listeners pour la gestions d'évènement
287
	 */
5 aperonnet 288
	public void ajouterListeners() {
268 aurelien 289
 
290
		modeZoom.addListener(new ButtonListenerAdapter() {
5 aperonnet 291
 
268 aurelien 292
			public void onClick(Button button, EventObject e) {
293
				// TODO Auto-generated method stub
294
				if(modeZoom.isPressed()) {
295
					modeZoom.toggle(false);
296
				} else {
297
					modeZoom.toggle(true);
298
				}
299
			}
300
 
301
			public void onToggle(Button button, boolean pressed) {
302
				if(pressed) {
303
					scroll = true;
304
					image.addStyleName("img-curseur-depl");
305
				} else  {
306
					scroll = false;
307
					image.removeStyleName("img-curseur-depl");
308
					niveauZoom = 1;
309
					verifierEtRetaillerImage();
310
					Ext.get(image.getElement()).center(imageConteneur.getElement());
311
				}
312
			}
313
		});
314
 
207 aurelien 315
		image.addLoadListener(new LoadListener() {
316
 
317
			public void onError(Widget sender) {
318
				// TODO Auto-generated method stub
319
			}
320
 
321
			public void onLoad(Widget sender) {
322
 
268 aurelien 323
				/*int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());
207 aurelien 324
				int[] tailleImage = calculerDimensions(getTailleImage(), max, max);
325
				ExtElement imgElement = Ext.get(image.getElement());
326
				if(animerTransition) {
327
					AnimationConfig a = new AnimationConfig() ;
328
					a.setDuration((float) dureeAnimation);
329
					imgElement.setHeight(tailleImage[1], a);
330
					imgElement.setWidth(tailleImage[0], a);
331
				} else {
332
					imgElement.setHeight(tailleImage[1], false);
333
					imgElement.setWidth(tailleImage[0], false);
268 aurelien 334
				}*/
335
				verifierEtRetaillerImage();
336
				Ext.get(image.getElement()).center(imageConteneur.getElement());
225 aurelien 337
				demasquerChargement();
207 aurelien 338
			}
339
 
340
		});
341
 
342
		image.addClickListener(new ClickListener() {
343
 
344
			public void onClick(Widget sender) {
268 aurelien 345
				if(!scroll) {
207 aurelien 346
					if(enClic) {
347
						getIMediateur().doubleClicZoomImage();
348
					} else {
349
						Timer t = new Timer() {
350
							public void run() {
351
								enClic = false;
352
							}
353
 
354
						};
355
						enClic = true;
356
						t.schedule(800);
357
					}
268 aurelien 358
				}
207 aurelien 359
			}
360
 
361
		});
362
 
363
		image.addMouseWheelListener(new MouseWheelListener() {
364
 
365
			public void onMouseWheel(Widget sender, MouseWheelVelocity velocity) {
366
 
367
				if(velocity.getDeltaY() > 0) {
268 aurelien 368
					if(scroll) {
369
						zoomOut();
370
					} else {
371
						suiv.click();
372
					}
207 aurelien 373
				} else {
268 aurelien 374
					if(scroll) {
375
						zoomIn();
376
					} else {
377
						prev.click();
378
					}
207 aurelien 379
				}
380
			}
381
 
382
		});
383
 
268 aurelien 384
		image.addMouseListener(new MouseListener() {
385
 
386
			public void onMouseDown(Widget sender, int x, int y) {
387
				if(scroll) {
388
					Event.getCurrentEvent().preventDefault();
389
					scroll = true;
390
					sourisX = x;
391
					sourisY = y;
392
					image.addStyleName("img-curseur-depl");
393
				}
394
			}
395
 
396
			public void onMouseEnter(Widget sender) {
397
				// TODO Auto-generated method stub
398
 
399
			}
400
 
401
			public void onMouseLeave(Widget sender) {
402
				// TODO Auto-generated method stub
403
 
404
			}
405
 
406
			public void onMouseMove(Widget sender, int x, int y) {
407
 
408
				sourisXFin = x;
409
				sourisYFin = y;
410
				Event.getCurrentEvent().preventDefault();
411
			}
412
 
413
			public void onMouseUp(Widget sender, int x, int y) {
414
 
415
				if(scroll) {
416
					Event.getCurrentEvent().preventDefault();
417
 
418
					if(sourisX - sourisXFin > 0) {
419
						Ext.get(image.getElement()).move(Direction.LEFT, sourisX - sourisXFin, false);
420
					}
421
 
422
					if(sourisXFin - sourisX > 0) {
423
						Ext.get(image.getElement()).move(Direction.RIGHT, sourisXFin - sourisX, false);
424
					}
425
 
426
					if(sourisY - sourisYFin > 0) {
427
						Ext.get(image.getElement()).move(Direction.UP, sourisY - sourisYFin, false);
428
					}
429
 
430
					if(sourisYFin - sourisY > 0) {
431
						Ext.get(image.getElement()).move(Direction.DOWN, sourisYFin - sourisY, false);
432
					}
433
				}
434
			}
435
 
436
		});
437
 
2 aperonnet 438
		// gestion du clic sur le bouton précedent
439
		prev.addClickListener(new ClickListener() {
440
 
441
			// en cas de clic
442
			public void onClick(Widget sender) {
443
				// on notifie le médiateur
225 aurelien 444
				masquerChargement();
2 aperonnet 445
				getIMediateur().clicBoutonZoomImage("prev");
446
			}
5 aperonnet 447
 
2 aperonnet 448
		});
5 aperonnet 449
 
2 aperonnet 450
		// gestion du clic sur le bouton suivant
451
		suiv.addClickListener(new ClickListener() {
452
 
453
			// en cas de clic
454
			public void onClick(Widget sender) {
5 aperonnet 455
				// on notifie le médiateur
225 aurelien 456
				masquerChargement();
2 aperonnet 457
				getIMediateur().clicBoutonZoomImage("suiv");
458
			}
5 aperonnet 459
 
2 aperonnet 460
		});
5 aperonnet 461
 
2 aperonnet 462
		// gestion du redimensionnement
463
		this.addListener(new PanelListenerAdapter() {
5 aperonnet 464
 
2 aperonnet 465
			// lors d'un redimensionnement de l'application
5 aperonnet 466
 
467
			public void onBodyResize(Panel panel, java.lang.String width,
468
					java.lang.String height) {
2 aperonnet 469
				// on vérifie et on retaille l'image
5 aperonnet 470
				verifierEtRetaillerImage();
2 aperonnet 471
			}
5 aperonnet 472
		});
473
 
2 aperonnet 474
		// gestion du redimensionnement lors de l'affichage du conteneur
475
		imageConteneur.addListener(new PanelListenerAdapter() {
5 aperonnet 476
 
2 aperonnet 477
			// avant de finir d'afficher
5 aperonnet 478
 
479
			public void onAfterLayout(Container self) {
2 aperonnet 480
				// on redimensionne
5 aperonnet 481
				verifierEtRetaillerImage();
2 aperonnet 482
			}
5 aperonnet 483
		});
2 aperonnet 484
	}
485
 
486
	/**
5 aperonnet 487
	 * Verifie si l'image est plus grande que le conteneur et la retaille le cas
488
	 * echeant
2 aperonnet 489
	 */
5 aperonnet 490
	public void verifierEtRetaillerImage() {
2 aperonnet 491
		// si l'image est nulle
5 aperonnet 492
		if (image == null) {
2 aperonnet 493
			// on ne fait rien
5 aperonnet 494
			return;
495
		}
496
 
2 aperonnet 497
		// on prend la taille originale de l'image
268 aurelien 498
		/*int originalX = getTailleImage()[0];
5 aperonnet 499
		int originalY = getTailleImage()[1];
500
 
501
		// on la transforme en float (la division entre entier donne de curieux
502
		// résultats)
503
		float fOriginalX = (new Float(originalX)).floatValue();
504
		float fOriginalY = (new Float(originalY)).floatValue();
505
 
2 aperonnet 506
		// et on fait le rapport longueur sur hauteur (pour connaitre le ratio)
5 aperonnet 507
		float rapportTaille = fOriginalX / fOriginalY;
508
 
2 aperonnet 509
		// la nouvelle taille est pour le moment égale à l'ancienne
5 aperonnet 510
		int nouvelleTailleX = originalX;
511
		int nouvelleTailleY = originalY;
512
 
2 aperonnet 513
		// on prend la taille du conteneur
5 aperonnet 514
		int tailleConteneurX = imageConteneur.getWidth();
268 aurelien 515
		int tailleConteneurY = imageConteneur.getHeight();*/
5 aperonnet 516
 
2 aperonnet 517
		// si celle-ci est égale à 0 (conteneur mal initialisé)
5 aperonnet 518
		/*
519
		 * if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
520
		 * essaie de la calculer en fonction de la taille du parent et des
521
		 * frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
522
		 * this.getWidth() - prev.getOffsetWidth() * 2 ;
523
		 *  }
524
		 */
268 aurelien 525
/*
5 aperonnet 526
		// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
527
		// grande)
528
		if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
2 aperonnet 529
			// si la longueur de l'image est la plus grande des deux
5 aperonnet 530
			if (originalX > originalY) {
531
				// on prend la longueur comme taille de référence, qu'on met à
532
				// la longueur du conteneur
533
				nouvelleTailleX = tailleConteneurX;
534
				// et on recalcule la hauteur, par rapport à la nouvelle
535
				// longueur, en gardant le format de 'limage
536
				nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1
537
						/ rapportTaille);
538
			} else {
539
				// si la hauteur est la plus grande, on fait le même genre
540
				// d'opération en prenant la hauteur comme référence
541
				nouvelleTailleY = tailleConteneurY;
542
				nouvelleTailleX = (int) Math.floor(nouvelleTailleY
543
						* rapportTaille);
2 aperonnet 544
			}
545
		}
268 aurelien 546
*/
2 aperonnet 547
		// on modifie enfin la taille de l'image pour qu'elle soit affichée
268 aurelien 548
		int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());
549
 
550
		int[] tailleImage = new int[2];
551
		ExtElement imgElement = Ext.get(image.getElement());
552
 
553
		if(max == imageConteneur.getHeight()) {
554
			//tailleImage[0] = getTailleImage()[0];
555
			//tailleImage[1] = max;
556
			imgElement.setHeight(max, false);
557
		} else {
558
			//tailleImage[1] = getTailleImage()[0];
559
			//tailleImage[0] = max;
560
			imgElement.setWidth(max, false);
561
		}
562
 
563
		//int[] tailleImage = calculerDimensions(getTailleImage(), max, max);
564
		//imgElement.
565
		/*if(animerTransition) {
566
			AnimationConfig a = new AnimationConfig() ;
567
			a.setDuration((float) dureeAnimation);
568
			imgElement.setHeight(tailleImage[1], a);
569
			imgElement.setWidth(tailleImage[0], a);
570
		} else {
571
			imgElement.setHeight(tailleImage[1], false);
572
			imgElement.setWidth(tailleImage[0], false);
573
		}*/
574
 
575
		String strZoom = ""+niveauZoom+"";
576
		strZoom = strZoom.substring(0,3);
577
 
578
		valeurZoom.setText("x "+strZoom);
2 aperonnet 579
	}
5 aperonnet 580
 
207 aurelien 581
	public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) {
582
 
583
		float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
584
        float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ;
585
        float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
586
        float[] XYresize = new float[2];
587
 
588
        if(maxTaille == tailleXY[0]) {
589
            float rapport = tailleXYf[1]/tailleXYf[0] ;
590
            XYresize[0] = tailleOr ;
591
            XYresize[1] = tailleOr*rapport ;
592
        }else {
593
            float rapport = tailleXYf[0]/tailleXYf[1] ;
594
            XYresize[1] = tailleOr ;
595
            XYresize[0] = tailleOr*rapport ;
596
        }
597
 
268 aurelien 598
        int[] res = {(int)Math.round(XYresize[0]*niveauZoom),(int) Math.round(XYresize[1]*niveauZoom)} ;
207 aurelien 599
 
600
        return res;
601
    }
602
 
5 aperonnet 603
	public void configDragAndDrop()
604
	{
2 aperonnet 605
 
5 aperonnet 606
		// on fabrique la nouvelle configuration
607
		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
608
		DropTargetConfig dtc = new DropTargetConfig();
609
		dtc.setdDdGroup("DragGroupName");
610
 
611
		//La drop target permet de gérer l'évenement onDrop sur l'élement courant
612
		@SuppressWarnings("unused")
613
		DropTarget tg = new DropTarget(this, dtc)
614
		{
615
			public boolean notifyDrop(DragSource source, EventObject e, DragData data){
616
 
617
				// si on reçoit des données provenant d'une grille
618
				if(data instanceof GridDragData)
619
		    	  {
620
		    		  		// on appelle le médiateur
621
		    		  		return iMediateur.lierObsDD(source, e, data,getId()) ;
622
		    	  }
623
				return false ;
624
			}
625
 
626
			public String notifyOver(DragSource source, EventObject e, DragData data){
627
			    return "x-dd-drop-ok";
628
			}
629
		};
630
 
631
	}
632
 
2 aperonnet 633
	/**
634
	 * Accesseur pour le médiateur
5 aperonnet 635
	 *
2 aperonnet 636
	 * @return le médiateur associé à la vue
637
	 */
638
	public ImageMediateur getIMediateur() {
639
		return iMediateur;
640
	}
641
 
642
	/**
643
	 * Accesseur au conteneur de l'image
5 aperonnet 644
	 *
2 aperonnet 645
	 * @return le conteneur de l'image
646
	 */
647
	public Image getImage() {
648
		return image;
649
	}
5 aperonnet 650
 
651
	/**
652
	 * Acesseurs pour l'identifiant de l'image
653
	 * @return l'id de l'image
654
	 */
655
	public String getIdImage()
656
	{
657
		return idImage ;
658
	}
2 aperonnet 659
 
660
	/**
661
	 * Accesseur pour le bouton précédent
5 aperonnet 662
	 *
2 aperonnet 663
	 * @return le bouton précédent
664
	 */
665
	public com.google.gwt.user.client.ui.Button getPrev() {
666
		return prev;
667
	}
668
 
669
	/**
670
	 * Accesseur pour le bouton suivant
5 aperonnet 671
	 *
2 aperonnet 672
	 * @return le bouton suivant
673
	 */
674
	public com.google.gwt.user.client.ui.Button getSuiv() {
675
		return suiv;
676
	}
5 aperonnet 677
 
2 aperonnet 678
	/**
679
	 * Setter pour la taille de l'image
5 aperonnet 680
	 *
7 aperonnet 681
	 * @param x
5 aperonnet 682
	 *            la largeur en pixels
7 aperonnet 683
	 * @param y
5 aperonnet 684
	 *            la hauteur en pixels
2 aperonnet 685
	 */
5 aperonnet 686
	public void setTailleImage(int x, int y) {
687
		imageHeight = y;
688
		imageWidth = x;
2 aperonnet 689
	}
690
 
691
	/**
5 aperonnet 692
	 * Setteur pour l'identifiant de l'image
693
	 * @param id le nouvel identifiant
694
	 */
695
	public void setIdImage(String id)
696
	{
697
		idImage = id ;
698
	}
699
 
700
	/**
2 aperonnet 701
	 * renvoie la taille originale de l'image
5 aperonnet 702
	 *
2 aperonnet 703
	 * @return un tableau de deux entiers contenant la largeur puis la hauteur
704
	 */
5 aperonnet 705
	public int[] getTailleImage() {
706
		int[] taille = { imageHeight, imageWidth };
707
 
708
		return taille;
2 aperonnet 709
	}
5 aperonnet 710
 
711
	/**
712
	 * Accesseur pour le conteneur de l'image
713
	 * @return le conteur de l'image
714
	 */
715
	public Panel getImageConteneur() {
2 aperonnet 716
 
5 aperonnet 717
		return imageConteneur;
718
 
2 aperonnet 719
	}
268 aurelien 720
 
721
	private void zoomOut() {
722
		if(niveauZoom >= minZoom) {
723
			niveauZoom -= pasZoom;
724
			if(niveauZoom <= minZoom) {
725
				niveauZoom = minZoom;
726
			}
727
			verifierEtRetaillerImage();
728
			gererDecalage(false);
729
		}
730
	}
731
 
732
	private void zoomIn() {
733
		if(niveauZoom < maxZoom ) {
734
			niveauZoom += pasZoom;
735
			if(niveauZoom >= maxZoom) {
736
				niveauZoom = maxZoom;
737
			}
738
			verifierEtRetaillerImage();
739
			gererDecalage(true);
740
		}
741
	}
742
 
743
	private void gererDecalage(boolean in) {
744
 
745
		float nZoom = niveauZoom;
746
 
747
		if(niveauZoom < 1) {
748
			nZoom = 1/niveauZoom;
749
		}
750
 
751
		if(!in) {
752
			int diffX = imageConteneur.getWidth()/2 - sourisX;
753
			int diffY = imageConteneur.getHeight()/2 - sourisY;
754
 
755
			if(diffX > 0) {
756
				Ext.get(image.getElement()).move(Direction.RIGHT, (int)((diffX/maxZoom)/nZoom), false);
757
			}
758
 
759
			if(-diffX > 0) {
760
				Ext.get(image.getElement()).move(Direction.LEFT, (int)(-(diffX/maxZoom)/nZoom), false);
761
			}
762
 
763
			if(diffY > 0) {
764
				Ext.get(image.getElement()).move(Direction.DOWN, (int)((diffY/maxZoom)/nZoom), false);
765
			}
766
 
767
			if(-diffY > 0) {
768
				Ext.get(image.getElement()).move(Direction.UP, (int)(-(diffY/maxZoom)/nZoom), false);
769
			}
770
		} else {
771
			int diffX = imageConteneur.getWidth()/2;
772
			int diffY = imageConteneur.getHeight()/2;
773
			if(diffX > 0) {
774
				Ext.get(image.getElement()).move(Direction.LEFT, (int)((diffX/maxZoom)/nZoom), false);
775
			}
776
 
777
			if(-diffX > 0) {
778
				Ext.get(image.getElement()).move(Direction.RIGHT, (int)((-diffX/maxZoom)/nZoom), false);
779
			}
780
 
781
			if(diffY > 0) {
782
				Ext.get(image.getElement()).move(Direction.UP, (int)((diffY/maxZoom)/nZoom), false);
783
			}
784
 
785
			if(-diffY > 0) {
786
				Ext.get(image.getElement()).move(Direction.DOWN, (int)(-(diffY/maxZoom)/nZoom), false);
787
			}
788
		}
789
	}
2 aperonnet 790
}