Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 4 → Rev 5

/trunk/src/org/tela_botanica/client/vues/ZoomImageVue.java
1,6 → 1,5
package org.tela_botanica.client.vues;
 
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
9,33 → 8,40
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
*/
44,56 → 50,60
* 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()
{
super() ;
private ZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
* @param im le médiateur à associer à la vue
*
* @param im
* 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 ;
prev.setStylePrimaryName("x-view-zoom-button-p") ;
suiv.setStylePrimaryName("x-view-zoom-button-s") ;
iMediateur = im;
 
prev.setStylePrimaryName("x-view-zoom-button-p");
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)) {
 
100,58 → 110,58
// 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)
{
prev.click() ;
if (event.getMouseWheelVelocityY() >= 1) {
prev.click();
}
 
// ou suivant
if(event.getMouseWheelVelocityY() <= -1)
{
suiv.click() ;
if (event.getMouseWheelVelocityY() <= -1) {
suiv.click();
}
}
}
};
this.setHeader(false) ;
imageConteneur = new Panel() ;
 
this.setHeader(false);
 
imageConteneur = new Panel() ;
imageConteneur.setBorder(false);
imageConteneur.add(image) ;
imageConteneur.setId("x-view-zoom-img") ;
// il n'existe pas de méthode pour ajouter un listener pour le double clic sur une image
 
imageConteneur.add(image);
imageConteneur.setId("x-view-zoom-img");
 
// 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(imageConteneur,new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv,new BorderLayoutData(RegionPosition.EAST));
imageConteneur.setMaskDisabled(true) ;
 
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
conteneurInitialise = true ;
initialise = true ;
configDragAndDrop() ;
 
// on ajoute les listeners
ajouterListeners();
 
159,61 → 169,59
 
/**
* Méthode héritée de l'interface rafraichissable
* @param nouvelleDonnees les nouvelles données
* @param repandreRafraichissement le booleen qui dit si on doit répnadre l'évènement
*
* @param nouvelleDonnees
* les nouvelles données
* @param repandreRafraichissement
* 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)
{
String[] infos = (String[])nouvelleDonnees ;
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise) {
String[] infos = (String[]) nouvelleDonnees;
// c'est l'url de l'image qu'on associe à la vue
getImage().setUrl(infos[0]);
if(infos[1] != null && infos[2] != null)
{
int x = Integer.parseInt(infos[1]) ;
int y = Integer.parseInt(infos[2]) ;
if (infos[0] != null && infos[1] != null && infos[2] != null && infos[3] != null) {
getImage().setUrl(infos[0]);
int x = Integer.parseInt(infos[1]);
int y = Integer.parseInt(infos[2]);
 
setTailleImage(x, y);
setTailleImage(x,y) ;
verifierEtRetaillerImage() ;
setIdImage(infos[3]) ;
 
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()
{
getImage().setUrl("vide.jpeg") ;
prev.setEnabled(false) ;
public void desactiverPanneau() {
getImage().setUrl("vide.jpeg");
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() {
 
222,111 → 230,144
// 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
// 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 originalY = getTailleImage()[1] ;
// on la transforme en float (la division entre entier donne de curieux résultats)
float fOriginalX = (new Float(originalX)).floatValue() ;
float fOriginalY = (new Float(originalY)).floatValue() ;
int originalX = getTailleImage()[0];
int originalY = getTailleImage()[1];
 
// on la transforme en float (la division entre entier donne de curieux
// résultats)
float fOriginalX = (new Float(originalX)).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 nouvelleTailleY = originalY ;
int nouvelleTailleX = originalX;
int nouvelleTailleY = originalY;
 
// on prend la taille du conteneur
int tailleConteneurX = imageConteneur.getWidth() ;
int tailleConteneurY = imageConteneur.getHeight() ;
int tailleConteneurX = imageConteneur.getWidth();
int tailleConteneurY = imageConteneur.getHeight();
 
// si celle-ci est égale à 0 (conteneur mal initialisé)
/*if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0)
{
// on essaie de la calculer en fonction de la taille du parent et des frères
tailleConteneurY = this.getHeight() ;
tailleConteneurX = this.getWidth() - prev.getOffsetWidth() * 2 ;
}*/
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop grande)
if(originalY > tailleConteneurY || originalX > tailleConteneurX)
{
/*
* if(imageConteneur.getHeight() == 0 && tailleConteneurX == 0) { // on
* essaie de la calculer en fonction de la taille du parent et des
* frères tailleConteneurY = this.getHeight() ; tailleConteneurX =
* this.getWidth() - prev.getOffsetWidth() * 2 ;
* }
*/
 
// si l'image ne rentre pas telle quelle (longueur ou hauteur trop
// grande)
if (originalY > tailleConteneurY || originalX > tailleConteneurX) {
// si la longueur de l'image est la plus grande des deux
if(originalX > originalY)
{
// on prend la longueur comme taille de référence, qu'on met à la longueur du conteneur
nouvelleTailleX = tailleConteneurX ;
// et on recalcule la hauteur, par rapport à la nouvelle longueur, en gardant le format de 'limage
nouvelleTailleY = (int)Math.floor(nouvelleTailleX*1/rapportTaille) ;
if (originalX > originalY) {
// on prend la longueur comme taille de référence, qu'on met à
// la longueur du conteneur
nouvelleTailleX = tailleConteneurX;
// et on recalcule la hauteur, par rapport à la nouvelle
// longueur, en gardant le format de 'limage
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() {
335,14 → 376,25
 
/**
* 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() {
351,37 → 403,53
 
/**
* 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 la largeur en pixels
* @param Y la hauteur en pixels
*
* @param X
* la largeur en pixels
* @param Y
* la hauteur en pixels
*/
public void setTailleImage(int x, int y)
{
imageHeight = y ;
imageWidth = x ;
public void setTailleImage(int x, int y) {
imageHeight = y;
imageWidth = x;
}
/**
* Setteur pour l'identifiant de l'image
* @param id le nouvel identifiant
*/
public void setIdImage(String id)
{
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 ;
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() {
 
public Panel getImageConteneur() {
return imageConteneur ;
return imageConteneur;
 
}
}