Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 1546 → Rev 1547

/branches/v1.6-croc/src/org/tela_botanica/client/vues/image/ZoomImageVue.java
New file
0,0 → 1,608
package org.tela_botanica.client.vues.image;
 
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.LoadEvent;
import com.google.gwt.event.dom.client.LoadHandler;
import com.google.gwt.event.dom.client.MouseWheelEvent;
import com.google.gwt.event.dom.client.MouseWheelHandler;
import com.google.gwt.user.client.Timer;
import com.google.gwt.user.client.ui.Image;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
 
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.ToolTip;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
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;
 
/**
* Panneau conteneur pour l'image
*/
private Panel imageConteneur = null;
/**
* l'image à afficher
*/
private Image image = new Image("vide.jpg");
/**
* Bouton précédent
*/
private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button();
/**
* 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;
 
/**
* Taille originale X de l'image
*/
private int imageWidth = 0;
/**
* Identifiant de l'image
*/
private String idImage = "0" ;
 
/**
* Booleen d'initalisation général
*/
private boolean initialise = false;
private Panel infosTaxon = new Panel();
 
/**
* Booleen d'initalisation du conteneur d'image
*/
private boolean conteneurInitialise = false;
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>") ;
/**.
* boolean de gestion du double clic
*/
private boolean enClic = false;
private ToolbarButton modeZoom = null;
private ToolbarTextItem valeurZoom = new ToolbarTextItem("x 1");
 
protected boolean scroll = false;
/**
* Constructeur sans argument (privé car ne doit être utilisé)
*/
@SuppressWarnings("unused")
private ZoomImageVue() {
super();
}
 
/**
* Constructeur avec argument
*
* @param im
* le médiateur à associer à la vue
*/
public ZoomImageVue(ImageMediateur im) {
super("Zoom");
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");
 
// on crée une image qui gère le double clic et la roulette de la souris
image = new Image();
this.setHeader(false);
 
imageConteneur = new Panel();
imageConteneur.setBorder(false);
 
imageConteneur.add(image);
imageConteneur.setId("x-view-zoom-img");
 
// l'image de base est vide
image.setUrl("vide.jpg");
 
this.setLayout(new BorderLayout());
 
prev.setWidth("60px");
suiv.setWidth("60px");
 
modeZoom = new ToolbarButton("Mode Zoom");
Toolbar tb = new Toolbar();
tb.addButton(modeZoom);
tb.addItem(valeurZoom);
//setTopToolbar(tb);
infosTaxon = new Panel();
infosTaxon.setHeader(false);
//infosTaxon.setBorder(false);
infosTaxon.setHeight("30px");
this.add(prev, new BorderLayoutData(RegionPosition.WEST));
this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER));
this.add(suiv, new BorderLayoutData(RegionPosition.EAST));
this.add(infosTaxon, new BorderLayoutData(RegionPosition.SOUTH));
 
imageConteneur.setMaskDisabled(true);
this.setBorder(false);
 
conteneurInitialise = true;
initialise = true;
configDragAndDrop() ;
 
// on ajoute les listeners
ajouterListeners();
tp.setDismissDelay(1050);
tp.applyTo(image.getElement()) ;
 
}
 
/**
* 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
*/
@Override
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
//niveauZoom = 1;
// si on reçoit une string
if (nouvelleDonnees instanceof String[] && initialise
&& conteneurInitialise) {
String[] infos = (String[]) nouvelleDonnees;
// c'est l'url de l'image qu'on associe à la vue
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);
setIdImage(infos[3]) ;
String infosTaxon = "" ;
if(infos.length == 5 && infos[4] != null) {
infosTaxon = infos[4];
}
setInfosTaxon(infosTaxon);
verifierEtRetaillerImage();
}
}
}
 
/**
* Desactive visuellement le panneau et les boutons
*/
public void desactiverPanneau() {
getImage().setUrl("vide.jpg");
prev.setEnabled(false);
suiv.setEnabled(false);
}
 
/**
* Active visuellement le panneau et les boutons
*/
public void activerPanneau() {
prev.setEnabled(true);
suiv.setEnabled(true);
}
public void masquerChargement() {
ExtElement imgEl = Ext.get(imageConteneur.getElement());
if(imgEl != null) {
imgEl.mask("Chargement");
}
}
public void demasquerChargement() {
ExtElement imgEl = Ext.get(imageConteneur.getElement());
if(imgEl != null) {
imgEl.unmask();
}
}
 
/**
* Ajoute les listeners pour la gestions d'évènement
*/
public void ajouterListeners() {
image.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
if(!scroll) {
if(enClic) {
getIMediateur().doubleClicZoomImage();
} else {
Timer t = new Timer() {
@Override
public void run() {
enClic = false;
}
};
enClic = true;
t.schedule(800);
}
}
}
});
image.addLoadHandler(new LoadHandler() {
@Override
public void onLoad(LoadEvent event) {
 
verifierEtRetaillerImage();
Ext.get(image.getElement()).center(imageConteneur.getElement());
demasquerChargement();
}
});
image.addMouseWheelHandler(new MouseWheelHandler() {
@Override
public void onMouseWheel(MouseWheelEvent event) {
if(event.isNorth()) {
masquerChargement();
getIMediateur().clicBoutonZoomImage("suiv");
} else {
masquerChargement();
getIMediateur().clicBoutonZoomImage("prev");
}
}
});
// gestion du clic sur le bouton précedent
prev.addClickHandler(new ClickHandler() {
 
// en cas de clic
@Override
public void onClick(ClickEvent event) {
// on notifie le médiateur
masquerChargement();
getIMediateur().clicBoutonZoomImage("prev");
}
});
 
// gestion du clic sur le bouton suivant
suiv.addClickHandler(new ClickHandler() {
 
// en cas de clic
@Override
public void onClick(ClickEvent event) {
// on notifie le médiateur
masquerChargement();
getIMediateur().clicBoutonZoomImage("suiv");
}
 
});
 
// gestion du redimensionnement
this.addListener(new PanelListenerAdapter() {
 
// lors d'un redimensionnement de l'application
 
@Override
public void onBodyResize(Panel panel, java.lang.String width,
java.lang.String height) {
// on vérifie et on retaille l'image
verifierEtRetaillerImage();
}
});
 
// gestion du redimensionnement lors de l'affichage du conteneur
imageConteneur.addListener(new PanelListenerAdapter() {
 
// avant de finir d'afficher
 
@Override
public void onAfterLayout(Container self) {
// on redimensionne
verifierEtRetaillerImage();
}
});
}
 
/**
* Verifie si l'image est plus grande que le conteneur et la retaille le cas
* echeant
*/
public void verifierEtRetaillerImage() {
// si l'image est nulle
if (image == null) {
// on ne fait rien
return;
}
// on modifie enfin la taille de l'image pour qu'elle soit affichée
int max = Math.min(imageConteneur.getHeight(), imageConteneur.getWidth());
int[] tailleImage = new int[2];
if(Ext.isIE()) {
image.setHeight(calculerDimensions(getTailleImage(),max,max)[1]+"px");
image.setWidth(calculerDimensions(getTailleImage(),max,max)[0]+"px");
} else {
if(max == imageConteneur.getHeight()) {
tailleImage[0] = getTailleImage()[0];
tailleImage[1] = max;
image.setHeight(max+"px");
} else {
tailleImage[1] = getTailleImage()[0];
tailleImage[0] = max;
image.setWidth(max+"px");
}
}
}
public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) {
float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ;
float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ;
float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ;
float[] XYresize = new float[2];
if(maxTaille == tailleXY[0]) {
float rapport = tailleXYf[1]/tailleXYf[0] ;
XYresize[0] = tailleOr ;
XYresize[1] = tailleOr*rapport ;
}else {
float rapport = tailleXYf[0]/tailleXYf[1] ;
XYresize[1] = tailleOr ;
XYresize[0] = tailleOr*rapport ;
}
int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ;
return res;
}
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)
{
@Override
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 ;
}
@Override
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() {
return iMediateur;
}
 
/**
* 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() {
return prev;
}
 
/**
* 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
*/
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 ;
}
public void setInfosTaxon(String nomTaxon) {
if(nomTaxon != null && !nomTaxon.equals("")) {
nomTaxon = getNomsObservationsFormatees(nomTaxon);
}
infosTaxon.setHtml("<div id='infos_taxon'><span class='texte_info_taxon'>"+nomTaxon+"</span></div>");
infosTaxon.doLayout();
}
 
/**
* 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 boolean estPortrait() {
return imageHeight > imageWidth;
}
public boolean estPaysage() {
return !estPortrait();
}
/**
* Accesseur pour le conteneur de l'image
* @return le conteur de l'image
*/
public Panel getImageConteneur() {
 
return imageConteneur;
 
}
private String getNomsObservationsFormatees(String nomObs) {
String htmlInfobulle = "";
String[][] obs = getObservationsAssociees(nomObs);
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][1] != null && !obs[i][1].equals("")) {
htmlInfobulle += ", "+obs[i][1];
}
}
htmlInfobulle = htmlInfobulle.replaceFirst(", ", "");
return htmlInfobulle;
}
private String[][] getObservationsAssociees(String nomObs) {
if(nomObs.trim().equals("")) {
return new String[0][0];
}
String[] obsTab = nomObs.split(";;");
String[][] obsAnalysees = new String[obsTab.length][3];
for(int i = 0; i < obsTab.length; i++) {
obsAnalysees[i] = obsTab[i].split("#");
}
return obsAnalysees;
}
private boolean[] estAssocieeTransmise(String nomObs) {
String[][] obs = getObservationsAssociees(nomObs);
boolean[] associeesTranmises = {false, false};
if(obs.length > 0) {
associeesTranmises[0] = true;
}
for(int i = 0; i < obs.length; i++) {
if(obs[i].length == 3 && obs[i][2] != null && obs[i][2].equals("1")) {
associeesTranmises[1] = true;
}
}
return associeesTranmises;
}
}
Property changes:
Added: svn:mergeinfo