| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,584 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.LoadListener; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.AnimationConfig; |
| 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.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Panneau d'affichage d'une image avec des boutons précdents et suivant |
| * |
| * @author aurelien |
| * |
| */ |
| public class MiniZoomImageVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Panneau conteneur pour l'image |
| */ |
| private Panel imageConteneur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(""); |
| /** |
| * 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" ; |
| private String[] infosImages[] = null ; |
| private int index = 0 ; |
| /** |
| * true pour animer les transitions |
| */ |
| private boolean animerTransition = false; |
| /** |
| * Détermine la durée de la transition |
| */ |
| private float dureeAnimation = (float) 0.15; |
| /** |
| * Booleen d'initalisation général |
| */ |
| private boolean initialise = false; |
| /** |
| * Booleen d'initalisation du conteneur d'image |
| */ |
| private boolean conteneurInitialise = false; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| Image imgAgrandie = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MiniZoomImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public MiniZoomImageVue(ObservationMediateur im) { |
| super("Image liées"); |
| setId("x-view-mini-zoom-panel"); |
| // on associe le médiateur |
| oMediateur = im; |
| prev.setStylePrimaryName("x-view-zoom-button-p"); |
| suiv.setStylePrimaryName("x-view-zoom-button-s"); |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| // 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 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(); |
| } |
| // ou suivant |
| if (event.getMouseWheelVelocityY() <= -1) { |
| suiv.click(); |
| } |
| } |
| if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) { |
| event.preventDefault() ; |
| int[] xy = {event.getClientX(),event.getClientY()} ; |
| afficherMenu(xy) ; |
| } |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| afficherPanneauAgrandi(); |
| } |
| } |
| }; |
| image.setPixelSize(150, 150); |
| infosImages = new String[0][0] ; |
| this.setHeader(true); |
| imageConteneur = new Panel() ; |
| imageConteneur.setBorder(false); |
| imageConteneur.add(image); |
| imageConteneur.setId("x-view-mini-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.ONCONTEXTMENU) ; |
| // l'image de base est vide |
| image.setUrl(""); |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("15%"); |
| suiv.setWidth("15%"); |
| 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; |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * 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 |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit une string |
| if (nouvelleDonnees instanceof String[][] && initialise |
| && conteneurInitialise && ((String[][])nouvelleDonnees).length != 0) { |
| infosImages = (String[][]) nouvelleDonnees; |
| index = 0 ; |
| afficherImage() ; |
| } else { |
| // sinon on met une image vide |
| infosImages = null ; |
| afficherImage(); |
| } |
| } |
| public void afficherImage() |
| { |
| // c'est l'url de l'image qu'on associe à la vue |
| if(infosImages != null && infosImages.length != 0) |
| { |
| activerPanneau() ; |
| getImage().setUrl(convertirIdEnUrl(infosImages[index][0])); |
| imageWidth = Integer.parseInt(infosImages[index][1]); |
| imageHeight = Integer.parseInt(infosImages[index][2]); |
| verifierEtRetaillerImage(); |
| } else { |
| getImage().setUrl("ill_liaison.png"); |
| imageWidth = getImage().getWidth(); |
| imageHeight = getImage().getHeight(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau() { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| // gestion du clic sur le bouton précedent |
| prev.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == infosImages.length - 1) |
| { |
| index = 0 ; |
| } |
| else |
| { |
| index++ ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * 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 infosImages[index][0] ; |
| } |
| /** |
| * 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 ; |
| } |
| /** |
| * 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; |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| public void raz() { |
| infosImages = new String[0][0] ; |
| getImage().setUrl(""); |
| } |
| public void supprimerLiaisonImage() { |
| if(infosImages.length > 0) { |
| getImage().setUrl("") ; |
| int nouvelleTaille = infosImages.length - 1 ; |
| int indexSupp = index ; |
| String[][] nouveauInfosImages = new String[nouvelleTaille][3] ; |
| int j = 0 ; |
| for(int i = 0 ; i < infosImages.length ; i++) { |
| if(i != indexSupp) { |
| nouveauInfosImages[j] = infosImages[i] ; |
| j++ ; |
| } |
| } |
| infosImages = nouveauInfosImages ; |
| index = 0 ; |
| afficherImage() ; |
| } |
| } |
| public void afficherMenu(int[] xy) { |
| Menu mn = new Menu() ; |
| final Item suppLiaison = new Item("Supprimer la liaison") ; |
| mn.addItem(suppLiaison) ; |
| mn.addListener(new MenuListenerAdapter() { |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'aide |
| if (item.equals(suppLiaison)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| } |
| }) ; |
| mn.showAt(xy) ; |
| } |
| public String convertirIdEnUrl(String idImg) |
| { |
| int maxZeros = 9 - idImg.length(); |
| for (int j = 0; j < maxZeros; j++) { |
| idImg = "0" + idImg; |
| } |
| String baseUrl = Configuration.getImageBaseUrl() ; |
| String dossierNv1 = idImg.substring(0, 3); |
| String dossierNv2 = idImg.substring(3, 6); |
| String fichierNv = idImg.substring(6, 9); |
| String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv; |
| String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 }; |
| String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/" |
| + infosFichier[0] + "_M.jpg"; |
| return urlImg ; |
| } |
| /** |
| * 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; |
| } |
| int[] dim = calculerDimensions(getTailleImage(),300,imageConteneur.getWidth()); |
| getImage().setSize("" + dim[0] + "px", |
| "" + dim[1] + "px"); |
| doLayout(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| } |
| 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; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = convertirIdEnUrl(infosImages[index][0]).replace("_M", "_L") ; |
| urlAgrandie = urlAgrandie.replace("/M/", "/L/") ; |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadListener(new LoadListener() { |
| public void onError(Widget sender) { |
| // TODO Auto-generated method stub |
| } |
| public void onLoad(Widget sender) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration((float) dureeAnimation); |
| imgElement.setHeight(tailleImage[1], a); |
| imgElement.setWidth(tailleImage[0], a); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], a); |
| winElement.setWidth(tailleImage[0], a); |
| } else { |
| imgElement.setHeight(tailleImage[1], false); |
| imgElement.setWidth(tailleImage[0], false); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], false); |
| winElement.setWidth(tailleImage[0], false); |
| } |
| } |
| }); |
| } else { |
| imgAgrandie.setUrl(urlAgrandie); |
| imgAgrandie.setVisible(true); |
| } |
| } |
| private void afficherPanneauAgrandi() { |
| imgZoom.show(this.getElement()); |
| agrandirImage(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,203 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant la repartition d'une plante |
| * |
| * @author David Delon |
| * |
| */ |
| public class InformationRepartitionVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private InformationRepartitionVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public InformationRepartitionVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| image.sinkEvents(Event.ONDBLCLICK); |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_choro.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // 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; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // 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 = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,202 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant une image generique provenant d eflore |
| * |
| * @author David Delon |
| * |
| */ |
| public class ImageGeneriqueVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ImageGeneriqueVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public ImageGeneriqueVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| this.setCls("x-image-gen") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_taxon.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| observationMediateur.deMasquerChargementInfosObservations() ; |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // 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; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // 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 = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.0-becassine/src/org/tela_botanica/client/vues/observation/indicateurs/NuageMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,166 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| public class NuageMotsClesVue extends Window implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAChercher = "" ; |
| private int nbMotsClesMax = 1 ; |
| private boolean nuageCharge = false ; |
| public NuageMotsClesVue(ObservationMediateur om) { |
| super("Nuage de mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| setWidth(200); |
| this.setCloseAction(CLOSE); |
| //oMediateur.obtenirNuageMotsCles(this); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| if(!nuageCharge) { |
| masquerChargement(); |
| } |
| } |
| @Override |
| public void onRender(Component component) { |
| } |
| @Override |
| public void onShow(Component component) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| } |
| } |
| private void construireNuage() { |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| public void onBrowserEvent(Event e) { |
| //oMediateur.ajouterMotCleRecherche(e.getTarget().getInnerHTML()); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| this.clear(); |
| this.add(contenuHTML); |
| doLayout(); |
| nuageCharge = true; |
| demasquerChargement(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |