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());
324 aurelien 273 
		if(imgEl != null) {
225 aurelien 274 
			imgEl.mask("Chargement");
275 
		}
276 
	}
277 
 
278 
	public void demasquerChargement() {
279 
		ExtElement imgEl = Ext.get(imageConteneur.getElement());
324 aurelien 280 
		if(imgEl != null) {
225 aurelien 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 
}