| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/BarreNotationVue.java |
|---|
| New file |
| 0,0 → 1,227 |
| 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.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.MouseListenerAdapter; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.widgets.Panel; |
| /** |
| * Une barre de notation avec des étoiles, tout ce qu'il ya de plus classique, |
| * utilisant Ajax (et pas CSS) |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreNotationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| @SuppressWarnings("unused") |
| private ImageMediateur iMediateur = null; |
| /** |
| * La note actuellement affichée |
| */ |
| private int noteEnCours = 0; |
| /** |
| * La note maximum |
| */ |
| private int noteMax = 0; |
| /** |
| * Booléen indiquant si une note est affectée à la barre en ce moment |
| */ |
| private boolean estNote = false; |
| /** |
| * Tablmeau d'images contenant les étoiles affichées |
| */ |
| private Image[] etoiles = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreNotationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| * @param noteMax |
| * la note maximale |
| */ |
| public BarreNotationVue(ImageMediateur im, int noteMax) { |
| iMediateur = im; |
| setNoteMax(noteMax); |
| this.setSize(200, 100); |
| this.setBodyBorder(false); |
| this.setBorder(false); |
| this.setCls("x-view-notation"); |
| ajouterListeners(); |
| } |
| public void ajouterListeners() { |
| for (int i = 0; i < etoiles.length; i++) { |
| etoiles[i].addMouseListener(new MouseListenerAdapter() { |
| // si la souris passe sur la barre |
| @Override |
| public void onMouseEnter(Widget sender) { |
| Image enCours = (Image) sender; |
| // on met en surbrillance toutes les étoiles allant de la |
| // première jusqu'à |
| // celle sous le curseur |
| for (int i = 0; etoiles[i] != enCours; i++) { |
| etoiles[i].setUrl("note-hover.gif"); |
| } |
| enCours.setUrl("note-hover.gif"); |
| } |
| // si la souris sort de la barre |
| @Override |
| public void onMouseLeave(Widget sender) { |
| // on affiche la véritable note |
| afficherNote(); |
| } |
| }); |
| etoiles[i].addClickListener(new ClickListener() { |
| // si on clique sur une étoiles |
| @Override |
| public void onClick(Widget sender) { |
| int i = 0; |
| // on récupère le numéro de l'étoile sur laquelle on a |
| // cliqué |
| while (etoiles[i] != (Image) sender) { |
| i++; |
| } |
| // et on affecte la note |
| noter(i); |
| } |
| }); |
| } |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| // si on recoit un tableau de string |
| if (nouvelleDonnees instanceof String[]) { |
| // on récupère le premier élément (un entier, qui contient la note) |
| String[] note = (String[]) nouvelleDonnees; |
| int noteInt = Integer.parseInt(note[0]); |
| // si l'entier est une note valide |
| if (noteInt != -1 && noteInt >= 0) { |
| noter(noteInt); |
| } |
| // sinon si l'entier vaut -1 |
| else { |
| // alors on note avec 0 |
| // et on met le booleen de notation a false (qui signifie que |
| // l'image n'est pas encore notée) |
| estNote = false; |
| noteEnCours = 0; |
| // et demande l'affichage |
| afficherNote(); |
| } |
| } |
| } |
| /** |
| * Affecte une note à la barre et rafraichit l'affichage |
| * |
| * @param note |
| * la nouvelle note |
| */ |
| public void noter(int note) { |
| // on affecte la note |
| noteEnCours = note; |
| // on met le boolean de notation à true (l'image est notée) |
| estNote = true; |
| // et on demande l'affichage |
| afficherNote(); |
| } |
| /** |
| * Setteur pour la note maximale |
| * |
| * @param nMax |
| * la nouvelle note maximale |
| */ |
| public void setNoteMax(int nMax) { |
| // on affecte la note |
| noteMax = nMax; |
| // on prépare le tableau d'image |
| etoiles = new Image[noteMax]; |
| // qu'on remplit par defaut avec des images d'étoiles vides |
| for (int i = 0; i < noteMax; i++) { |
| etoiles[i] = new Image("note-off.gif"); |
| etoiles[i].setStylePrimaryName("x-view-notation-bar"); |
| this.add(etoiles[i]); |
| } |
| } |
| /** |
| * Affiche la note d'une image sous la forme d'étoiles |
| */ |
| public void afficherNote() { |
| // si l'image est notée |
| if (estNote) { |
| // on affiche autant d'étoiles que le chiffre de la note |
| for (int i = 0; i <= noteEnCours; i++) { |
| etoiles[i].setUrl("note-on.gif"); |
| } |
| // et si elle est inférieure à la note maximale, on remplit le reste |
| // par des étoiles vides |
| for (int j = noteEnCours + 1; j < noteMax; j++) { |
| etoiles[j].setUrl("note-off.gif"); |
| } |
| } |
| // sinon |
| else { |
| // on remplit toute la barre avec des étoiles vides |
| for (int i = 0; i < noteMax; i++) { |
| etoiles[i].setUrl("note-off.gif"); |
| } |
| } |
| } |
| /** |
| * Accesseur pour la note en cours sous forme de string |
| * |
| * @return la note en cours sous forme d'une chaine de charactères |
| */ |
| public String getNote() { |
| return "" + noteEnCours; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/MenuImageVue.java |
|---|
| New file |
| 0,0 → 1,190 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| 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.MenuItem; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Menu de gestion des images |
| * |
| * @author aurelien |
| * |
| */ |
| public class MenuImageVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour l'upload |
| */ |
| private MenuItem uploaderImage = null; |
| /** |
| * Item pour la suppression |
| */ |
| private Item supprimerImage = null; |
| /** |
| * Item pour l'ajout d'images à la selection |
| */ |
| private Item ajouterImageSelection = null; |
| /** |
| * Item pour vider la selection d'images |
| */ |
| private Item viderSelection = null; |
| /** |
| * Item pour lier la selection d'images |
| */ |
| private Item afficherSelection = null; |
| private Item uploadMultiple = null ; |
| private Item uploadSimple = null ; |
| private Item gestionMotsCles = null; |
| private Menu mn = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuImageVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| mn = new Menu(); |
| uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois"); |
| uploadSimple = new Item("Un fichier à la la fois"); |
| mn.addItem(uploadMultiple); |
| mn.addItem(uploadSimple); |
| // on construit le menu |
| uploaderImage = new MenuItem("Ajouter des images", mn); |
| supprimerImage = new Item("Supprimer les images selectionnées"); |
| gestionMotsCles = new Item("Gérer les mots clés"); |
| ajouterImageSelection = new Item( |
| "Ajouter les images sélectionnées au tampon"); |
| viderSelection = new Item("Vider le tampon"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(uploaderImage); |
| addItem(supprimerImage); |
| addItem(gestionMotsCles); |
| addSeparator() ; |
| addItem(ajouterImageSelection); |
| addItem(viderSelection); |
| addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(supprimerImage)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerImages(); |
| } |
| // si c'est l'ajout à la sélection |
| if (item.equals(ajouterImageSelection)) { |
| getIMediateur().ajouterImagesSelection(); |
| } |
| // si c'est le vidage de la sélection |
| if (item.equals(viderSelection)) { |
| getIMediateur().viderSelection(); |
| } |
| // si c'est l'affichage de la selection |
| if (item.equals(afficherSelection)) { |
| getIMediateur().afficherIdSelectionImages(); |
| } |
| // si c'est l'affichage de la selection |
| if (item.equals(gestionMotsCles)) { |
| getIMediateur().afficherFenetreGestionMotsCles(); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| @Override |
| public void onShow(Menu menu) { |
| if(getIMediateur().getCompteSelection() != 0) { |
| afficherSelection.enable(); |
| viderSelection.enable(); |
| } |
| else { |
| afficherSelection.disable(); |
| viderSelection.disable(); |
| } |
| } |
| }); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'upload |
| if (item.equals(uploadMultiple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(true); |
| } |
| // si c'est l'upload |
| if (item.equals(uploadSimple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(false); |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /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 |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/ArbreDateImageFiltreVue.java |
|---|
| New file |
| 0,0 → 1,588 |
| package org.tela_botanica.client.vues.image.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.DateObservation; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| /** |
| * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton |
| * cliquable |
| * |
| * @author aurelien |
| * |
| */ |
| public class ArbreDateImageFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur imageMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String donneesDateEnCours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreDonneesDates = null; |
| /** |
| * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue |
| */ |
| private Tree donneesDates = new Tree(); |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| private String prefixeId = "date_image_"; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreDateImageFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreDateImageFiltreVue(ImageMediateur imgMed) { |
| // on crée le panel |
| super("Dates"); |
| this.imageMediateur = imgMed; |
| arbreDonneesDates = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| this.setBorder(false); |
| arbreDonneesDates.setBorder(false); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| // on interdit le drag and drop dans l'arbre |
| arbreDonneesDates.setEnableDD(false); |
| arbreDonneesDates.setId("x-view-tree-filter-date-image"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Dates"); |
| root.addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages(); |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.setRootVisible(true); |
| setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreDonneesDates); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| public void ajouterListeners() { |
| arbreDonneesDates.addListener(new TreePanelListenerAdapter() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages(); |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| imageMediateur.obtenirPhotoGalerie() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| nomFiltre = "" ; |
| donneesDateEnCours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(arbreCharge) { |
| nomFiltre = ""; |
| donneesDateEnCours = ""; |
| } |
| break; |
| case 3: nomFiltre += "annee,mois,jour"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 2: nomFiltre += "annee,mois"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 1: nomFiltre += "annee"; |
| donneesDateEnCours += ((String[])node.getUserObject())[1] ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| arbreDonneesDates.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDate) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDate data = (ListeDate) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText("Dates"); |
| String[] usObjRoot = { "Dates", "Dates", prefixeId+"racine_date"}; |
| root.setUserObject(usObjRoot); |
| Tree nouvelArbre = new Tree(); |
| nouvelArbre.setRootNode(root); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| DateObservation ent=data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ; |
| jour= ent.getJour() ; |
| if(annee.contains("0000")) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00")) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = nouvelArbre.getNodeById(prefixeId+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = nouvelArbre.getNodeById(prefixeId+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = nouvelArbre.getNodeById(prefixeId+(annee+mois+jour)); |
| if(noeudMemeJour != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(prefixeId+(annee+mois+jour)); |
| node_jour.setText(jour); |
| noeudMemeMois.appendChild(node_jour) ; |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(prefixeId+(annee+mois)); |
| node_mois.setText(moisLettre); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(prefixeId+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(prefixeId+annee); |
| node_annee.setText(annee); |
| root.appendChild(node_annee) ; |
| String[] usObj = {annee, annee, annee}; |
| node_annee.setUserObject(usObj); |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(prefixeId+(annee+mois)); |
| node_mois.setText(moisLettre); |
| node_annee.appendChild(node_mois) ; |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(prefixeId+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| } |
| } |
| // on trie |
| root.sort(comparerNoeuds()) ; |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // et on recopie le nouvel arbre |
| copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates |
| .getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!estInstancie) { |
| // on signale que oui |
| estInstancie = true; |
| } |
| // l'état du filtre est réinitialisé |
| filtreModifie = false; |
| //show() ; |
| doLayout(); |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreDonneesDates; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Dates"; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String[] valeursFiltrees = new String[0]; |
| if(!nomFiltre.trim().equals("") && !donneesDateEnCours.trim().equals("")) { |
| valeursFiltrees = new String[2]; |
| valeursFiltrees[0] = nomFiltre; |
| valeursFiltrees[1] = donneesDateEnCours; |
| } |
| return valeursFiltrees; |
| } |
| /** |
| * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
| * copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
| * |
| * @param ndPereOriginal |
| * le père des noeuds de l'arbre original |
| * @param ndPereCopie |
| * le père qui va recevoir les copies |
| */ |
| private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) { |
| if (ndPereCopie != null && ndPereOriginal != null) { |
| Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
| for (int i = 0; i < ndNodeFils.length; i++) { |
| String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
| TreeNode child = new TreeNode(usObj[0]); |
| child.setUserObject(usObj); |
| child.setId(prefixeId+usObj[2]); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| /** |
| * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.clear(); |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirDatesImages() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| public void obtenirDatesImages() { |
| imageMediateur.obtenirDatesImages(this); |
| } |
| @Override |
| public void viderFiltre() { |
| donneesDateEnCours = ""; |
| arbreDonneesDates.getSelectionModel().clearSelections(); |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("annee")) { |
| profondeur = 1; |
| } |
| if(nom.equals("mois")) { |
| profondeur = 2; |
| } |
| if(nom.equals("jour")) { |
| profondeur = 3; |
| } |
| return profondeur; |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/RechercheFiltreTaxonVue.java |
|---|
| New file |
| 0,0 → 1,118 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| public class RechercheFiltreTaxonVue extends Panel implements Filtrable { |
| private ImageMediateur iMediateur = null; |
| private TextField champRecherche = null; |
| private static String titrePanneau = "Recherche libre"; |
| private String valeurRecherchee= ""; |
| private Button boutonRechercher = null; |
| private boolean estModifie = true; |
| private final int KEY_ENTER = 13; |
| public RechercheFiltreTaxonVue(ImageMediateur im) { |
| super(titrePanneau); |
| iMediateur = im; |
| champRecherche = new TextField(); |
| champRecherche.setWidth("90%"); |
| boutonRechercher = new Button("Rechercher"); |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche Libre"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = "recherche"; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| nom = "recherche"; |
| } else { |
| nom = "recherche"; |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| @Override |
| public void valider() { |
| if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
| estModifie = true; |
| iMediateur.obtenirNombreMiniListeObservations(); |
| } else { |
| estModifie = false; |
| } |
| } |
| public void raz() { |
| if(champRecherche.isCreated()) { |
| champRecherche.reset(); |
| valeurRecherchee = ""; |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| valeurRecherchee = ""; |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/PanneauFiltresImagesVues.java |
|---|
| New file |
| 0,0 → 1,208 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| /** |
| * Panneau contenant les filtres qu'on peut appliquer aux images |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauFiltresImagesVues extends Panel { |
| /** |
| * Le médiateur associé |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * L'arbre pour la recherche par mots clés |
| */ |
| private ArbreMotsClesFiltreVue motsClesFiltres = null; |
| /** |
| * L'arbre pour la recherche par mots clés |
| */ |
| private ArbreDateImageFiltreVue arbreDateImageFiltreVue = null; |
| /** |
| * La barre de recherche libre |
| */ |
| private BarreRechercheFiltreVue rechercheLibreFiltreVue = null; |
| /** |
| * Recherche par contenu du tampon |
| */ |
| private SelectionFiltreVue selectionFiltreVue = null; |
| /** |
| * Bouton de validation |
| */ |
| private Button valider = null; |
| /** |
| * Construcuteur sans argument (privé car on ne doit pas l'utiliser) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauFiltresImagesVues() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public PanneauFiltresImagesVues(ImageMediateur im) { |
| super("Filtres"); |
| iMediateur = im; |
| this.setCollapsible(true); |
| setLayout(new RowLayout()); |
| rechercheLibreFiltreVue = new BarreRechercheFiltreVue(im); |
| rechercheLibreFiltreVue.setTitle("Recherche libre"); |
| rechercheLibreFiltreVue.setCollapsible(true); |
| add(rechercheLibreFiltreVue, new RowLayoutData()); |
| if(Ext.isIE()) { |
| add(rechercheLibreFiltreVue); |
| rechercheLibreFiltreVue.setHeight(110); |
| } else { |
| add(rechercheLibreFiltreVue,new RowLayoutData(100)); |
| } |
| arbreDateImageFiltreVue = new ArbreDateImageFiltreVue(im) ; |
| arbreDateImageFiltreVue.setWidth("100%") ; |
| arbreDateImageFiltreVue.setBorder(false); |
| add(arbreDateImageFiltreVue, new RowLayoutData()); |
| motsClesFiltres = new ArbreMotsClesFiltreVue(im); |
| motsClesFiltres.setTitle("Mots clés"); |
| motsClesFiltres.setAutoScroll(true); |
| add(motsClesFiltres, new RowLayoutData()); |
| selectionFiltreVue = new SelectionFiltreVue(im); |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onRender(Component component) { |
| // TODO Auto-generated method stub |
| rechercheLibreFiltreVue.ajouterListeners(); |
| arbreDateImageFiltreVue.ajouterListeners(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreMotsClesFiltreVue getMotsClesFiltre() { |
| return motsClesFiltres; |
| } |
| /** |
| * Accesseur pour le filtre général |
| * |
| * @return le filtre général |
| */ |
| public BarreRechercheFiltreVue getBarreRecherche() { |
| return rechercheLibreFiltreVue; |
| } |
| /** |
| * Accesseur pour le filtre des dates |
| * |
| * @return le filtre des dates |
| */ |
| public ArbreDateImageFiltreVue getArbreDateRecherche() { |
| return arbreDateImageFiltreVue; |
| } |
| /** |
| * Renvoie un booléen indiquant si un des filtres a été modifié |
| * |
| * @return true sur un des filtres est modifié, false sinon |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return (motsClesFiltres.renvoyerEtatFiltre() |
| || rechercheLibreFiltreVue.renvoyerEtatFiltre() |
| || arbreDateImageFiltreVue.renvoyerEtatFiltre() |
| || selectionFiltreVue.renvoyerEtatFiltre()); |
| } |
| /** |
| * Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre", |
| * "valeur" |
| * |
| * @return un tableau contenant les noms et les valeurs à filtrer |
| */ |
| public String[][] renvoyerValeursAFiltrer() { |
| String[] filtresDates = arbreDateImageFiltreVue.renvoyerValeursAFiltrer(); |
| int lgSup = 0; |
| if(filtresDates.length > 0) { |
| String[] nomFiltresDates = filtresDates[0].split(","); |
| String[] valFiltresDates = filtresDates[1].split(","); |
| lgSup = Math.max(nomFiltresDates.length, valFiltresDates.length); |
| } |
| String[][] filtres = new String[3 + lgSup][2]; |
| for(int i=3; i < filtres.length; i++) { |
| filtres[i][0] = filtresDates[0].split(",")[i - 3]; |
| filtres[i][1] = filtresDates[1].split(",")[i -3]; |
| } |
| filtres[0] = motsClesFiltres.renvoyerValeursAFiltrer(); |
| filtres[1] = rechercheLibreFiltreVue.renvoyerValeursAFiltrer(); |
| filtres[2] = selectionFiltreVue.renvoyerValeursAFiltrer(); |
| return filtres; |
| } |
| public void viderFiltres() { |
| motsClesFiltres.viderFiltre(); |
| rechercheLibreFiltreVue.viderFiltre(); |
| arbreDateImageFiltreVue.viderFiltre(); |
| selectionFiltreVue.viderFiltre(); |
| } |
| public void viderFiltre(String nom) { |
| if(nom.equals("id_mots_cles")) { |
| motsClesFiltres.viderFiltre(); |
| } |
| if(nom.equals("recherche")) { |
| rechercheLibreFiltreVue.viderFiltre(); |
| } |
| if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) { |
| arbreDateImageFiltreVue.viderFiltre(nom); |
| } |
| if(nom.equals("ci_id_tampon")) { |
| selectionFiltreVue.viderFiltre(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/BarreRechercheFiltreVue.java |
|---|
| New file |
| 0,0 → 1,191 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| /** |
| * Fenêtre de recherche pour les mots clés, contenant un champ texte, et un |
| * bouton cliquable |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreRechercheFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Barre de recherche |
| * |
| */ |
| private TextField champRecherche = null; |
| /** |
| * Booleen d'etat du filtre |
| */ |
| private boolean filtreModifie = false; |
| private Button boutonRechercher = null; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| private final int KEY_ENTER = 13; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreRechercheFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec médiateur |
| * |
| * @param im |
| */ |
| public BarreRechercheFiltreVue(ImageMediateur im) { |
| super(); |
| setLayout(new HorizontalLayout(3)); |
| iMediateur = im; |
| champRecherche = new TextField(); |
| boutonRechercher = new Button("OK"); |
| add(champRecherche); |
| add(boutonRechercher); |
| setPaddings(5); |
| setBorder(false); |
| setAutoWidth(true); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| public void ajouterListeners() { |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| iMediateur.obtenirPhotoGalerie(iMediateur.getGalerieImage()); |
| break; |
| } |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche "; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider() ; |
| String[] valeurFiltre = { "recherche", motsAChercher }; |
| return valeurFiltre; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Effectue quelque opérations dans la classe et envoie une requête de |
| * données au médiateur |
| */ |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/filtres/SelectionFiltreVue.java |
|---|
| New file |
| 0,0 → 1,98 |
| package org.tela_botanica.client.vues.image.filtres; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.form.Checkbox; |
| public class SelectionFiltreVue extends Panel implements Filtrable { |
| private ImageMediateur iMediateur = null; |
| private boolean filtreModifie = false; |
| private Checkbox check = null; |
| @SuppressWarnings("unused") |
| private SelectionFiltreVue() |
| { |
| super() ; |
| } |
| public SelectionFiltreVue(ImageMediateur im) { |
| super(); |
| iMediateur = im ; |
| Label labelRecherche = new Label( |
| "Afficher uniquement les images dans le tampon :"); |
| add(labelRecherche); |
| setBorder(false); |
| setPaddings(5); |
| /* |
| * combo = new ComboBox() ; String tout = "toutes les images "; String |
| * selection = "dans le tampon seulement" ; Object[][] data = new |
| * Object[2][2]; data[0][0] = 1 ; data[0][1] = tout ; data[1][0] = 2 ; |
| * data[1][1] = selection ; |
| * // creation du store qui les contient FieldDef defIdChoix = new |
| * IntegerFieldDef("id_choix"); FieldDef defNomChoix = new |
| * StringFieldDef("nom_choix"); |
| * |
| * FieldDef[] defTab = {defIdChoix, defNomChoix}; RecordDef rd = new |
| * RecordDef(defTab) ; |
| * |
| * final MemoryProxy dataProxy = new MemoryProxy(data); final |
| * ArrayReader reader = new ArrayReader(rd); |
| * |
| * st = new Store(dataProxy, reader); st.load() ; combo.setStore(st) ; |
| * combo.setGrow(true) ; combo.setMode(ComboBox.LOCAL); |
| * combo.setEditable(false) ; //combo.setDisplayField("nom_choix") ; |
| * add(combo) ; |
| */ |
| check = new Checkbox(); |
| check.setChecked(false) ; |
| add(check); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Filtre par tampon"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| if (check.getValue()) { |
| String[] val = { "ci_id_tampon", iMediateur.renvoyerSelection() }; |
| return val; |
| } |
| String[] val = { "ci_id_tampon", "" }; |
| return val; |
| } |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| } |
| @Override |
| public void viderFiltre() { |
| check.setChecked(false); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/MiniListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,640 |
| package org.tela_botanica.client.vues.image; |
| import java.util.Iterator; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.util.Util; |
| import org.tela_botanica.client.vues.MiniBarrePaginationVue; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.grid.CellMetadata; |
| import com.gwtext.client.widgets.grid.ColumnConfig; |
| import com.gwtext.client.widgets.grid.ColumnModel; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.Renderer; |
| import com.gwtext.client.widgets.grid.event.GridListenerAdapter; |
| 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; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.dd.DragData; |
| /** |
| * liste d'observation pour l'association d'images aux observations |
| * @author aurelien |
| * |
| */ |
| public class MiniListeObservationVue extends GridPanel implements Rafraichissable, ListePaginable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null ; |
| /** |
| * Booléen d'instanciation |
| */ |
| private boolean estInstancie = false ; |
| /** |
| * Le modèle de colonnes |
| */ |
| private ColumnModel colModel = null ; |
| private SimpleStore store = null ; |
| private MiniBarrePaginationVue pgBar = new MiniBarrePaginationVue(this) ; |
| private Toolbar bt = new Toolbar() ; |
| /** |
| * Combobox permettant de selectionner le mode |
| * modification ou bien création |
| */ |
| private ComboBox selecteurMode = new ComboBox(); |
| Store storeMode = null ; |
| private boolean liaison; |
| int pageEnCours = 0; |
| int nbElements = 0; |
| int taillePage = 50; |
| private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION"; |
| /** |
| * Nombre de pages totales |
| */ |
| private int pageMax = 1 ; |
| /** |
| * Constructeur avec arguments |
| * @param im le médiateur à associer à la vue |
| */ |
| public MiniListeObservationVue(ImageMediateur im) |
| { |
| iMediateur = im ; |
| this.setId("x-view-mini-obs") ; |
| // on construit le modèle de colonnes |
| // Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) |
| Renderer colRend = new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) { |
| return "" ; |
| } |
| return value.toString() ; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) { |
| return "" ; |
| } |
| else |
| { |
| String dateEntiere = value.toString() ; |
| String[] dateEtHeure = dateEntiere.split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| String[] dateFormateeTab = dateEtHeure[0].split("-",3); |
| return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ; |
| } |
| } |
| return value.toString() ; |
| } |
| } ; |
| // on crée un store simple contenant un petit set de données et deux colonnes |
| store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, getObs()); |
| ColumnConfig[] columns = { |
| new ColumnConfig("", "transmis", 30, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value.equals("1")) |
| { |
| return "<img src=\"tela.png\"/></img>" ; |
| } |
| else |
| { |
| return "" ; |
| } |
| } |
| }), |
| new ColumnConfig("Taxon", "plante", 145, true, colRend), |
| new ColumnConfig("Date", "date", 68, true, dateRend), |
| new ColumnConfig("Lieu", "lieu", 145, true, colRend), |
| new ColumnConfig("Numero", "ordre_obs", 50, true, colRend), } ; |
| ColumnModel columnModel = new ColumnModel(columns); |
| colModel = columnModel ; |
| setTitle("Observations"); |
| // on associe le modèle de colonnes |
| setColumnModel(columnModel); |
| setAutoScroll(true) ; |
| setHeight("100%") ; |
| setAutoWidth(true) ; |
| // on autorise le drag 'n drop pour un certain groupe |
| this.setEnableDragDrop(true); |
| this.setDdGroup("DragGroupName"); |
| store.load(); |
| setStore(store) ; |
| setBottomToolbar(pgBar) ; |
| Object[][] mode = {{"toutes les observations",false} , {"observations liées", true} }; |
| storeMode = new SimpleStore(new String[] { "nom_mode", "mode" }, |
| mode); |
| storeMode.load(); |
| selecteurMode.setStore(storeMode); |
| selecteurMode.setDisplayField("nom_mode") ; |
| selecteurMode.setLabel("mode ") ; |
| selecteurMode.setForceSelection(true) ; |
| selecteurMode.setValue("toutes les observations") ; |
| selecteurMode.setEditable(false) ; |
| selecteurMode.setCls("x-selec-consult") ; |
| bt = new Toolbar() ; |
| bt.addField(selecteurMode) ; |
| //this.setAutoExpandColumn("plante"); |
| setTopToolbar(bt) ; |
| selecteurMode.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| // et on met la valeur à jour dans la combobox |
| comboBox.setValue(record.getAsString("nom_mode")); |
| setModification(record.getAsString("mode")) ; |
| } |
| }); |
| setAutoScroll(true) ; |
| // on configure le drag 'n drop |
| configDragAndDrop() ; |
| this.addGridListener(new GridListenerAdapter() { |
| @Override |
| public void onContextMenu(EventObject e) { |
| // si pas de selection, on selection au moins la ligne sur laquelle on a fait le clic |
| if(getSelectionModel().getSelections().length <= 0) { |
| int index = getView().findRowIndex(e); |
| Record rddrop = getStore().getRecordAt(index) ; |
| getSelectionModel().selectRecords(rddrop); |
| } |
| e.stopEvent() ; |
| MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ; |
| mlv.showAt(e.getXY()) ; |
| } |
| }) ; |
| obtenirNombreMiniListeObservations(); |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| // on choisit le texte qui sera affiché lors d'un drag 'n drop |
| setDragDropText("Faites glisser la selection d'observations sur une image pour les lier") ; |
| //On active le drag 'n drop |
| this.setEnableDragDrop(true); |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| this.setDdGroup("DragGroupName"); |
| 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 la convertit |
| GridDragData gdd = (GridDragData)data ; |
| // et on vérifie que les données ne viennent pas de l'élément courant |
| if(gdd.getGrid().getId().equals("x-view-mini-obs")) |
| { |
| return false ; |
| } |
| else |
| { |
| // on appelle le médiateur |
| return iMediateur.lierImagesDD(source, e, data) ; |
| } |
| } |
| return false ; |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof ListeObservation) |
| { |
| if(this.getView() != null) |
| { |
| ListeObservation data = (ListeObservation)nouvelleDonnees ; |
| String[][] listeObs = new String[data.size()][6] ; |
| int i = 0 ; |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| Observation obs=data.get(it.next()); |
| listeObs[i][0] = obs.getTransmis(); |
| listeObs[i][1] = obs.getNomSaisi(); |
| listeObs[i][2] = obs.getDate() ; |
| listeObs[i][3] = Util.formaterLieu(obs, modeleLieu); |
| listeObs[i][4] = obs.getNumeroOrdre(); |
| listeObs[i][5] = obs.getId(); |
| i++ ; |
| } |
| store = new SimpleStore(new String[]{"transmis","plante","date","lieu","ordre_obs","id_obs"}, listeObs); |
| store.load(); |
| this.reconfigure(store, colModel) ; |
| } |
| else |
| { |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onShow(Component c) |
| { |
| obtenirNombreMiniListeObservations() ; |
| } |
| @Override |
| public void onAfterLayout(Container c) |
| { |
| obtenirNombreMiniListeObservations() ; |
| } |
| }) ; |
| } |
| } |
| // Si on reçoit un tableau d'entiers |
| // c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères |
| if(nouvelleDonnees instanceof int[]) |
| { |
| int[] pages = (int[])nouvelleDonnees ; |
| // on calcule le nombre de pages nécessaires et on les met à jour dans le modèle |
| pageMax = calculerNbPages(pages[0]) ; |
| nbElements = pages[0]; |
| // et on notifie de le mediateur du changement des valeurs |
| changerPageMaxEtCourante(pageMax,pageEnCours,taillePage,nbElements) ; |
| masquerChargement(); |
| obtenirMiniListeObservations(); |
| } |
| redimensionner(); |
| deMasquerChargement() ; |
| } |
| private void obtenirMiniListeObservations() |
| { |
| iMediateur.obtenirMiniListeObservations(this, taillePage, pageEnCours) ; |
| } |
| private void obtenirNombreMiniListeObservations() |
| { |
| iMediateur.obtenirNombreMiniListeObservations(this) ; |
| } |
| /** |
| * Renvoie le faux set de données pour le store |
| * @return un tableau à deux colonnes int - String |
| */ |
| private Object[][] getObs() { |
| return new Object[][]{ |
| } ; |
| } |
| @Override |
| public Store getStore() |
| { |
| return store ; |
| } |
| public MiniBarrePaginationVue getBarrePagination() |
| { |
| return pgBar ; |
| } |
| private void setModification(String mode) |
| { |
| if(mode.equals("true")) { |
| liaison = true ; |
| selecteurMode.removeClass("x-selec-consult") ; |
| selecteurMode.setCls("x-selec-liaison") ; |
| getBarrePagination().disable(); |
| doLayout(); |
| } |
| else |
| { |
| liaison = false ; |
| selecteurMode.removeClass("x-selec-liaison") ; |
| selecteurMode.setCls("x-selec-consult") ; |
| getBarrePagination().enable(); |
| doLayout(); |
| } |
| store.removeAll() ; |
| iMediateur.changerModeLiaison(liaison) ; |
| } |
| public boolean getMode() { |
| return liaison ; |
| } |
| /** |
| * 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 affiche son message de chargement |
| */ |
| public void deMasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| public String getIdSelectionnees() { |
| Record[] sels = getSelectionModel().getSelections() ; |
| String id = ""; |
| for(int i = 0; i < sels.length; i++) { |
| id += ","+sels[i].getAsString("id_obs") ; |
| } |
| id = id.replaceFirst(",", ""); |
| return id ; |
| } |
| public void supprimerLiaison() { |
| Record[] rdObs = getSelectionModel().getSelections() ; |
| for(int i = 0 ; i < rdObs.length ; i++) { |
| getStore().remove(rdObs[i]) ; |
| this.getView().refresh() ; |
| } |
| } |
| public void redimensionner() { |
| if(getView() != null) { |
| int taille = 400; |
| if(Window.getClientHeight() > 800 ) { |
| taille = Window.getClientHeight() - 350; |
| } |
| setHeight(taille); |
| getView().setForceFit(true); |
| doLayout(); |
| } |
| else { |
| } |
| } |
| /** |
| * Montre le menu de liaison aux coordonnées indiquées |
| * @param e |
| */ |
| public void montrerContextMenuLiaison(EventObject e) { |
| final Menu liObs = new Menu(); |
| final Item lierObservation = new Item("Lier aux images selectionnées"); |
| liObs.addItem(lierObservation); |
| liObs.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject ev) { |
| // si c'est la suppression |
| if (item.equals(lierObservation)) { |
| // on notifie le médiateur |
| } |
| // enfin, on cache le menu |
| liObs.hide(); |
| } |
| }); |
| liObs.showAt(e.getXY()); |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| pageEnCours = pageCourante ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| iMediateur.obtenirNombreMiniListeObservations(this); |
| } |
| /** |
| * Appelle le modèle pour qu'il change la taille de page utilisée |
| * @param nouvelleTaillePage la nouvelle taille de page |
| */ |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) |
| { |
| taillePage = nouvelleTaillePage ; |
| pageEnCours = calculerPageCourante(nbElements) ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| iMediateur.obtenirNombreMiniListeObservations(this); |
| // et on met à jour la taille de page dans les barres d'outils |
| pgBar.selectionnerTaillePage(nouvelleTaillePage); |
| } |
| /** |
| * Met à jour les barre d'outils avec des nouvelles valeurs |
| * @param pageMax le nombre de pages |
| * @param pageEncours la page en cours |
| * @param taillePage la taille de page |
| * @param nbElement le nombre d'élements par page |
| */ |
| public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) |
| { |
| int[] pages = {pageMax,pageEncours, taillePage, nbElement} ; |
| pgBar.rafraichir(pages, false) ; |
| } |
| /** |
| * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page |
| * en cours |
| * @param nbElements le nombre d'élements total |
| * @return le nombre de pages |
| */ |
| public int calculerNbPages(int nbElements) |
| { |
| // A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement |
| // pour eviter qu'il arrondisse mal la division |
| // nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur |
| double nPage = (1.0*nbElements)/(1.0*taillePage) ; |
| double nPageRound = Math.ceil(nPage) ; |
| Double nPageInt = new Double(nPageRound) ; |
| // on convertit en entier |
| return nPageInt.intValue() ; |
| } |
| /** |
| * Recalcule la page en cours lors du changement du nombre d'élements |
| * @param nbElements le nombre d'élements total |
| * @return la nouvelle page encours |
| */ |
| public int calculerPageCourante(int nbElements) |
| { |
| // on calcule le nombre de page |
| int nouvelNbPages = calculerNbPages(nbElements) ; |
| // la nouvelle page en cours |
| double nPageCourante = (1.0*pageEnCours)/(1.0*pageMax) * (1.0*nouvelNbPages) ; |
| // on arrondit au supérieur |
| double nPageRound = Math.ceil(nPageCourante) ; |
| Double nPageInt = new Double(nPageRound) ; |
| // on convertit en entier |
| return Math.abs(nPageInt.intValue()) ; |
| } |
| public boolean verifierFormatDate(String date) { |
| String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ; |
| if(date.matches(regex) && !date.equals("0000-00-00")) { |
| return true ; |
| } |
| else { |
| return false; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/PanneauMetadonneesVue.java |
|---|
| New file |
| 0,0 → 1,526 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.vues.image.ImageMotsClesVue; |
| import org.tela_botanica.client.vues.image.filtres.RechercheFiltreTaxonVue; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.NameValuePair; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.TabPanel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.DateField; |
| import com.gwtext.client.widgets.form.TextArea; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.GridView; |
| import com.gwtext.client.widgets.grid.PropertyGridPanel; |
| import com.gwtext.client.widgets.grid.event.GridCellListenerAdapter; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| /** |
| * Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il |
| * implémente l'interface rafraichissable |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauMetadonneesVue extends TabPanel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur imediateur = null; |
| /** |
| * Le panneau des Exifs |
| */ |
| private PropertyGridPanel ExifGrid = null; |
| /** |
| * Le panneau des Iptc |
| */ |
| private PropertyGridPanel IptcGrid = null; |
| /** |
| * La grille pour le panneau des Exifs |
| */ |
| private GridView gViewExif = null; |
| /** |
| * La grille pour le panneau de Iptc |
| */ |
| private GridView gViewIptc = null; |
| /** |
| * L'onglet des Exifs |
| */ |
| private Panel panneauExifGrid = null; |
| /** |
| * L'onglet des Iptc |
| */ |
| private Panel panneauIptcGrid = null; |
| /** |
| * L'onglet des infos |
| */ |
| private Panel panneauInfoGrid = null; |
| /** |
| * L'onglet des mots clés |
| */ |
| private ImageMotsClesVue panneauMotsCles = null; |
| /** |
| * l'onglet des observations |
| */ |
| private Panel panneauMiniListeObservation = null; |
| /** |
| * Le champ commentaire |
| */ |
| private TextField commentaireGeneral = null; |
| /** |
| * Le champ date |
| */ |
| private DateField dateImage = null; |
| /** |
| * La barre de recherche rapide des taxons |
| */ |
| private RechercheFiltreTaxonVue rechercheFiltreTaxonVue = null; |
| /** |
| * La mini liste des observations |
| */ |
| private MiniListeObservationVue miniListeObservation = null ; |
| /** |
| * Le bouton de validation |
| */ |
| Button validerInfo = null; |
| /** |
| * Barre de notation |
| */ |
| BarreNotationVue noteVue = null; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false; |
| Timer timerRedimensionnement = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauMetadonneesVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| */ |
| public PanneauMetadonneesVue(ImageMediateur im) { |
| super(); |
| // on associe le médiateur |
| imediateur = im; |
| // on crée et dispose les panneaux et les champs |
| panneauExifGrid = new Panel("Exif"); |
| panneauIptcGrid = new Panel("Iptc"); |
| panneauInfoGrid = new Panel("Infos"); |
| panneauMotsCles = new ImageMotsClesVue(im); |
| panneauMotsCles.setHeight("50%"); |
| Panel sousPanneauInfosGenerales = new Panel("Infos Générales"); |
| sousPanneauInfosGenerales.setLayout(new VerticalLayout()); |
| sousPanneauInfosGenerales.setBorder(false); |
| sousPanneauInfosGenerales.setHeight(200); |
| sousPanneauInfosGenerales.setAutoWidth(true); |
| sousPanneauInfosGenerales.setMargins(5); |
| sousPanneauInfosGenerales.setPaddings(5); |
| sousPanneauInfosGenerales.setCollapsible(true); |
| Label labelComm = new Label("Commentaires :"); |
| labelComm.setHeight("20px"); |
| commentaireGeneral = new TextArea(); |
| commentaireGeneral.setWidth("90%"); |
| Label labelDate = new Label("Date :"); |
| Label labelNote = new Label("Note :"); |
| panneauMotsCles.setBorder(false); |
| labelDate.setHeight("20px"); |
| dateImage = new DateField(); |
| dateImage.setAutoWidth(true); |
| dateImage.setFormat("d/m/Y"); |
| validerInfo = new Button("OK"); |
| noteVue = new BarreNotationVue(im, 5); |
| panneauMiniListeObservation = new Panel("Observations") ; |
| if(!Ext.isIE()) { |
| panneauMiniListeObservation.setLayout(new RowLayout()); |
| } |
| miniListeObservation = new MiniListeObservationVue(im); |
| rechercheFiltreTaxonVue = new RechercheFiltreTaxonVue(im); |
| rechercheFiltreTaxonVue.setTitle("Recherche dans les observations"); |
| if(Ext.isIE()) { |
| panneauMiniListeObservation.add(rechercheFiltreTaxonVue); |
| rechercheFiltreTaxonVue.setHeight(90); |
| } else { |
| panneauMiniListeObservation.add(rechercheFiltreTaxonVue, new RowLayoutData(90)); |
| } |
| rechercheFiltreTaxonVue.setWidth("100%") ; |
| rechercheFiltreTaxonVue.setBorder(false); |
| if(Ext.isIE()) { |
| panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData(400)) ; |
| } else { |
| panneauMiniListeObservation.add(miniListeObservation, new RowLayoutData()) ; |
| } |
| sousPanneauInfosGenerales.add(labelComm); |
| sousPanneauInfosGenerales.add(commentaireGeneral); |
| sousPanneauInfosGenerales.add(labelDate); |
| sousPanneauInfosGenerales.add(dateImage); |
| sousPanneauInfosGenerales.add(labelNote); |
| sousPanneauInfosGenerales.add(noteVue); |
| sousPanneauInfosGenerales.add(validerInfo); |
| sousPanneauInfosGenerales.setAutoHeight(true); |
| panneauMotsCles.setAutoHeight(true); |
| panneauInfoGrid.setBorder(false); |
| panneauInfoGrid.setAutoHeight(true); |
| panneauExifGrid.setAutoScroll(true); |
| panneauIptcGrid.setAutoScroll(true); |
| panneauInfoGrid.add(sousPanneauInfosGenerales); |
| panneauInfoGrid.add(panneauMotsCles); |
| this.add(panneauMiniListeObservation) ; |
| this.add(panneauInfoGrid); |
| this.add(panneauExifGrid); |
| this.add(panneauIptcGrid); |
| gViewExif = new GridView(); |
| gViewExif.setForceFit(true); |
| ExifGrid = new PropertyGridPanel(); |
| ExifGrid.setId("meta_exif"); |
| ExifGrid.setView(gViewExif); |
| ExifGrid.setNameText("Métadonnées Exif"); |
| ExifGrid.setAutoWidth(true); |
| ExifGrid.setHeight(500); |
| ExifGrid.setSorted(false); |
| ExifGrid.setAutoScroll(true); |
| gViewIptc = new GridView(); |
| gViewIptc.setForceFit(true); |
| IptcGrid = new PropertyGridPanel(); |
| IptcGrid.setId("meta_iptc"); |
| IptcGrid.setView(gViewIptc); |
| IptcGrid.setNameText("Métadonnées IPTC"); |
| IptcGrid.setAutoWidth(true); |
| IptcGrid.setHeight(500); |
| IptcGrid.setSorted(false); |
| IptcGrid.setAutoScroll(true); |
| panneauExifGrid.add(ExifGrid); |
| panneauIptcGrid.add(IptcGrid); |
| // on ajoute les listeners |
| ajouterListeners(); |
| // on effectue le rendu |
| //this.doLayout(true); |
| } |
| private void ajouterListeners() { |
| // on ajoute un écouteur |
| validerInfo.addListener(new ButtonListenerAdapter() { |
| // gestion du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| button.focus(); |
| // lors du clic sur le bouton valider on met à jour les |
| // commentaires et la date |
| getIMediateur().mettreAJourInfo(commentaireGeneral.getText(), |
| dateImage.getRawValue(), noteVue.getNote()); |
| } |
| }); |
| // gestion des clics dans la grille |
| ExifGrid.addGridCellListener(new GridCellListenerAdapter() { |
| // lors d'un clic d'une cellule |
| @Override |
| public void onCellClick(GridPanel grid, int rowIndex, int colIndex, |
| EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| // lors du double clic sur une cellule |
| @Override |
| public void onCellDblClick(GridPanel grid, int rowIndex, |
| int colIndex, EventObject e) { |
| // on empêche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| }); |
| IptcGrid.addGridCellListener(new GridCellListenerAdapter() { |
| // lors d'un clic d'une cellule |
| @Override |
| public void onCellClick(GridPanel grid, int rowIndex, int colIndex, |
| EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| // lors d'un double clic d'une cellule |
| @Override |
| public void onCellDblClick(GridPanel grid, int rowIndex, |
| int colIndex, EventObject e) { |
| // on empeche l'édition |
| e.stopEvent(); |
| ExifGrid.stopEditing(); |
| } |
| }); |
| panneauMiniListeObservation.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| if(Window.getClientHeight() > 800 ) { |
| taille = Window.getClientHeight() - 226; |
| } |
| panneauMiniListeObservation.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| panneauExifGrid.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| taille = Window.getClientHeight() - 150; |
| ExifGrid.setHeight(taille); |
| panneauExifGrid.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| panneauExifGrid.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, |
| int rawWidth, int rawHeight) { |
| timerRedimensionnement = new Timer() { |
| @Override |
| public void run() { |
| int taille = 500; |
| taille = Window.getClientHeight() - 150; |
| IptcGrid.setHeight(taille); |
| panneauIptcGrid.setHeight(taille); |
| } |
| }; |
| timerRedimensionnement.schedule(300); |
| } |
| }); |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() { |
| panneauInfoGrid.setDisabled(true); |
| panneauExifGrid.setDisabled(true); |
| panneauIptcGrid.setDisabled(true); |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() { |
| panneauInfoGrid.setDisabled(false); |
| panneauExifGrid.setDisabled(false); |
| panneauIptcGrid.setDisabled(false); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return imediateur; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen de notification de mise à jour |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit un tableau d'objets |
| if (nouvelleDonnees instanceof Object[]) { |
| final Object ressourceObject = nouvelleDonnees; |
| if(!this.isRendered()) { |
| addListener(new PanelListenerAdapter() { |
| @Override |
| public void onRender(Component component) { |
| rafraichir(ressourceObject, false); |
| } |
| }); |
| return ; |
| } |
| // extrait infos, exifs et iptc |
| Object meta[] = (Object[]) nouvelleDonnees; |
| String[][] exif = (String[][]) meta[0]; |
| String[][] iptc = (String[][]) meta[1]; |
| final String[][] gen = (String[][]) meta[2]; |
| NameValuePair[] exifSource = new NameValuePair[exif.length]; |
| NameValuePair[] iptcSource = new NameValuePair[iptc.length]; |
| int maxLength; |
| if (exif.length <= iptc.length) { |
| maxLength = iptc.length; |
| } else { |
| maxLength = exif.length; |
| } |
| for (int i = 0; i < maxLength; i++) { |
| if (i < exif.length && !exif[i][0].equals("null")) { |
| exifSource[i] = new NameValuePair(exif[i][0], exif[i][1]); |
| } |
| if (i < iptc.length && !iptc[i][0].equals("null")) { |
| iptcSource[i] = new NameValuePair(iptc[i][0], iptc[i][1]); |
| } |
| } |
| // on met à jour les champs avec la bonne valeur |
| commentaireGeneral.setValue(gen[0][1]); |
| dateImage.setValue(gen[1][1]); |
| // et on met à jour les données pour l'affichage |
| ExifGrid.setSource(exifSource); |
| IptcGrid.setSource(iptcSource); |
| } |
| } |
| /** |
| * Accesseur pour le panneau des mots clés |
| * |
| * @return the panneauMotsCles |
| */ |
| public ImageMotsClesVue getPanneauMotsCles() { |
| return panneauMotsCles; |
| } |
| public BarreNotationVue getNoteVue() { |
| return noteVue; |
| } |
| public MiniListeObservationVue getMiniListeObservation() |
| { |
| return miniListeObservation ; |
| } |
| public RechercheFiltreTaxonVue getRechercheFiltreTaxonVue() |
| { |
| return rechercheFiltreTaxonVue ; |
| } |
| public void redimensionner() { |
| if(panneauMiniListeObservation.isCreated() && panneauMiniListeObservation.isVisible()) { |
| panneauMiniListeObservation.doLayout(); |
| //panneauMiniListeObservation.show(); |
| miniListeObservation.redimensionner(); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/BarreOutilsVue.java |
|---|
| New file |
| 0,0 → 1,235 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.util.Util; |
| import org.tela_botanica.client.vues.MenuAideVue; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.SplitButton; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarMenuButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.SplitButtonListenerAdapter; |
| /** |
| * Barre d'outils contenant le menu de gestion des images (accessible aussi par |
| * un clic droit dans la galerie) et d'autres menus et boutons utiles |
| * |
| * @author aurelien |
| * |
| */ |
| public class BarreOutilsVue extends Toolbar { |
| /** |
| * Un bouton qui sert à déployer le menu |
| */ |
| ToolbarMenuButton images = null; |
| /** |
| * Un bouton qui sert à déployer le menu |
| */ |
| ToolbarMenuButton utilisateur = null; |
| /** |
| * Bouton pour déployer le menu d'aide |
| */ |
| ToolbarMenuButton aide = null ; |
| /** |
| * Le médiateur associé à la toolbar |
| */ |
| ImageMediateur iMediateur = null; |
| /** |
| * Le menu de gestion des images |
| */ |
| MenuImageVue imageMenu = null; |
| /** |
| * Le menu de gestion des filtres |
| */ |
| OptionsImages imageMenuEtendu = null; |
| /** |
| * L'item affichant les filtres en cours |
| */ |
| ToolbarTextItem texteFiltres; |
| /** |
| * Le menu de gestion utilisateur |
| */ |
| MenuIdVue idMenu = null; |
| /** |
| * Menu de gestion d'aide |
| */ |
| MenuAideVue aideMenu = null ; |
| /** |
| * Constructeur sans argument (ne doit pas être utilisé donc privé) |
| */ |
| @SuppressWarnings("unused") |
| private BarreOutilsVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public BarreOutilsVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| imageMenu = new MenuImageVue(im); |
| imageMenuEtendu = new OptionsImages(im); |
| //aideMenu = new MenuAideVue(im); |
| //images = new ToolbarMenuButton("Fichiers", imageMenu); |
| //aide = new ToolbarMenuButton("Aide", aideMenu); |
| texteFiltres = new ToolbarTextItem(""); |
| final ToolbarMenuButton menuImage = new ToolbarMenuButton("Ajouter des images", imageMenuEtendu.getMenuImage()); |
| menuImage.addListener(new SplitButtonListenerAdapter() { |
| @Override |
| public void onArrowClick(SplitButton menuButton, EventObject e) { |
| menuImage.showMenu(); |
| } |
| @Override |
| public void onClick(Button button, EventObject e) { |
| menuImage.showMenu(); |
| } |
| }); |
| ToolbarButton menuSuppression = imageMenuEtendu.getBoutonSuppression(); |
| final ToolbarMenuButton menuTampon = new ToolbarMenuButton("Tampon", imageMenuEtendu.getMenuTampon()); |
| menuTampon.addListener(new SplitButtonListenerAdapter() { |
| @Override |
| public void onArrowClick(SplitButton menuButton, EventObject e) { |
| menuTampon.showMenu(); |
| } |
| @Override |
| public void onClick(Button button, EventObject e) { |
| menuTampon.showMenu(); |
| } |
| }); |
| ToolbarButton menuGestionMotsCles = new ToolbarButton("Gérer les mots clés"); |
| menuGestionMotsCles.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| getIMediateur().afficherFenetreGestionMotsCles(); |
| } |
| }); |
| this.addButton(menuImage); |
| this.addButton(menuSuppression); |
| this.addButton(menuGestionMotsCles); |
| this.addButton(menuTampon); |
| this.addItem(texteFiltres); |
| //this.addButton(aide); |
| } |
| /** |
| * @return the images |
| */ |
| public ToolbarMenuButton getImages() { |
| return images; |
| } |
| /** |
| * @return the iMediateur |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| public void setFiltresEnCours(String[][] filtresEnCours) { |
| String texteFiltresEnCours = ""; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours += " - "; |
| } |
| texteFiltresEnCours += "<span class=\"affichage_filtre\">"+ |
| transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+ |
| " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_img_"+filtresEnCours[i][0]+"\" />"+ |
| "</span>"; |
| } |
| } |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>"; |
| } |
| texteFiltres.setText(texteFiltresEnCours); |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]) != null) { |
| Ext.get("bouton_raz_filtres_img_"+filtresEnCours[i][0]).addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| e.stopEvent(); |
| iMediateur.viderFiltre(e.getTarget().getAttribute("rel")); |
| } |
| }); |
| } |
| } |
| } |
| } |
| private String transformerNomFiltre(String nomFiltre) { |
| if(nomFiltre.equals("id_mots_cles")) { |
| nomFiltre = "mots clés"; |
| } |
| return nomFiltre; |
| } |
| private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) { |
| String valeurFiltreTransformee = valeurFiltre; |
| if(nomFiltre.equals("id_mots_cles")) { |
| String[] tabMotsCles = valeurFiltre.split(";"); |
| String[] tabMotsClesTexte = iMediateur.getTexteMotsCles(tabMotsCles); |
| if(tabMotsClesTexte.length > 1) { |
| valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte); |
| } else { |
| valeurFiltreTransformee = tabMotsClesTexte[0]; |
| } |
| } |
| if(nomFiltre.equals("mois")) { |
| valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre)); |
| } |
| return valeurFiltreTransformee; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/FenetreGestionMotsCles.java |
|---|
| New file |
| 0,0 → 1,636 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.WindowListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.HorizontalLayout; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| import com.gwtext.client.widgets.tree.TreeEditor; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| /** |
| * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots |
| * clés cochables et réorganisables à volonté |
| * |
| * @author aurelien |
| * |
| */ |
| public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable { |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreMotsCles = null; |
| /** |
| * L'éditeur qui permet de modifier les mots clés dans l'arbre |
| */ |
| private TreeEditor te = null; |
| /** |
| * Le textfield associé à l'éditeur |
| */ |
| private TextField tfEdit = null; |
| /** |
| * Bouton de validation |
| */ |
| private Button valider = null; |
| /** |
| * Bouton d'annulation |
| */ |
| private Button annuler = null; |
| /** |
| * Bouton d'ajout de tag |
| */ |
| private ToolbarButton ajouterTag = null; |
| /** |
| * Bouton de suppression de tag |
| */ |
| private ToolbarButton supprimerTag = null; |
| /** |
| * Bouton de renommage de tag |
| */ |
| private ToolbarButton renommerTag = null; |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| private String[] tableauMotsClesEnCours = new String[0]; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un |
| * noeud |
| */ |
| private boolean ajoutNoeud = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train de modifier un |
| * noeud |
| */ |
| private boolean modifNoeud = false; |
| /** |
| * Booléen d'instanciation du conteneur |
| */ |
| private boolean arbreCharge = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public FenetreGestionMotsCles() { |
| // on crée le panel |
| setTitle("Mots clés"); |
| this.setLayoutData(new VerticalLayout()); |
| // on crée le conteneur de l'arbre |
| arbreMotsCles = new TreePanel(); |
| // on permet le drag and drop dans l'arbre |
| arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setId("x-view-tree-keyword-imgs"); |
| arbreMotsCles.setSelectionModel(new MultiSelectionModel()); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine"); |
| String[] usObject = { "Mots clés", "racine" }; |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| arbreMotsCles.setWidth(500); |
| root.setUserObject(usObject); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| tfEdit.setAutoWidth(true); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| valider = new Button("Appliquer"); |
| annuler = new Button("Annuler"); |
| arbreMotsCles.add(te); |
| Panel panelIntermediaire = new Panel(); |
| panelIntermediaire.setLayoutData(new VerticalLayout()); |
| Panel panelBoutons = new Panel(); |
| panelBoutons.setLayout(new HorizontalLayout(130)); |
| panelBoutons.setWidth("100%"); |
| // on met en forme le layout |
| panelIntermediaire.add(arbreMotsCles); |
| panelBoutons.add(annuler); |
| panelBoutons.add(valider); |
| this.add(panelIntermediaire); |
| this.add(panelBoutons); |
| arbreMotsCles.setHeight("338px"); |
| Toolbar barreBouton = new Toolbar(); |
| ajouterTag = new ToolbarButton("Nouveau Tag"); |
| ajouterTag.setIcon("mot_cle_ajouter.png"); |
| renommerTag = new ToolbarButton("Renommer"); |
| renommerTag.setIcon("mot_cle_editer.png"); |
| renommerTag.disable(); |
| supprimerTag = new ToolbarButton("Supprimer"); |
| supprimerTag.setIcon("mot_cle_supprimer.png"); |
| supprimerTag.disable(); |
| barreBouton.addButton(ajouterTag); |
| barreBouton.addSeparator(); |
| barreBouton.addButton(renommerTag); |
| barreBouton.addSeparator(); |
| barreBouton.addButton(supprimerTag); |
| this.setTopToolbar(barreBouton); |
| setCloseAction(com.gwtext.client.widgets.Window.HIDE); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Acesseur pour l'arbre des mots clés |
| * |
| * @return le panel contenant l'arbre |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreMotsCles; |
| } |
| /** |
| * Accesseur pour l'éditeur |
| * |
| * @return l'éditeur associé à l'arbre |
| */ |
| public TreeEditor getTe() { |
| return te; |
| } |
| /** |
| * Acesseur pour le TextField associé à l'éditeur |
| * |
| * @return le champ texte associé à l'éditeur |
| */ |
| public TextField getTfEdit() { |
| return tfEdit; |
| } |
| protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te); |
| protected abstract void surAjoutMotCle(TreeNode node, Tree arbre); |
| protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre); |
| protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre); |
| protected abstract void surChangementTexte(TreeNode node, Tree arbre); |
| protected abstract void surClicValider(String chaineMotsCles, Tree arbre); |
| protected abstract void demanderArbreMotsCles(Rafraichissable r); |
| /** |
| * Ajoute les listeners nécessaires pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| arbreMotsCles.addListener(new TreePanelListenerAdapter() { |
| @Override |
| public void onExpandNode(TreeNode node) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| // gestion du clic sur un noeud |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| gererClicNoeud(node); |
| if(!node.equals(arbreMotsCles.getRootNode())) { |
| supprimerTag.enable(); |
| renommerTag.enable(); |
| } |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| surAffichageMenuContextuel(node, e, getTe()); |
| if(!node.equals(arbreMotsCles.getRootNode())) { |
| supprimerTag.enable(); |
| renommerTag.enable(); |
| } |
| } |
| // gestion de la modification du texte d'un noeud |
| @Override |
| public void onTextChange(TreeNode node, String text, String oldText) { |
| if(node.equals(arbreMotsCles.getRootNode())) { |
| return; |
| } |
| // on récupère les informations associées au noeud |
| TreeNode nd = node; |
| String[] usObject = new String[2]; |
| usObject[0] = text; |
| usObject[1] = ((String[]) nd.getUserObject())[1]; |
| nd.setUserObject(usObject); |
| // si c'est un nouveau noeud |
| if (ajoutNoeud) { |
| // on considère l'ajout achevé |
| ajoutNoeud = false; |
| // et on notifie le médiateur de l'ajout et on lui passe |
| // l'arbre |
| surAjoutMotCle(nd, getArbreMotsCles().getTree()); |
| } |
| // si c'est noeud déjà existant |
| else { |
| // on considère la modification achevée |
| modifNoeud = false; |
| if(!text.equals(oldText)) { |
| // et on notifie le médiateur de la modification et on lui |
| // passe l'arbre |
| surChangementTexte(nd, getArbreMotsCles().getTree()); |
| } |
| } |
| } |
| // gestion du déplacement d'un noeud |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| surDeplacementMotCle(node, getArbreMotsCles().getTree()); |
| } |
| }); |
| // gestion de la validation |
| valider.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // on vide les mots clés en cours |
| motsClesEnCours = ""; |
| // pour chaque noeud à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // on éxécute une fonction |
| @Override |
| public boolean execute(Node node) { |
| // on récupère le mot clé associé au noeud et |
| // ses infos |
| TreeNode tn = getArbreMotsCles().getNodeById( |
| node.getId()); |
| String[] usObject = (String[]) tn |
| .getUserObject(); |
| /*getIMediateur().mettreAjourMotsClesId( |
| usObject[0], usObject[1]);*/ |
| if (tn.getUI().isChecked()) { |
| // et les concatène à la string des mots |
| // clés en cours |
| motsClesEnCours += usObject[1] + ","; |
| } |
| return true; |
| } |
| }); |
| // enfin on notifie le médiateur et on lui passe l'arbre et la |
| // liste des mots clés ainsi obtenue |
| surClicValider(motsClesEnCours, arbreMotsCles.getTree()); |
| } |
| }); |
| annuler.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| hide(); |
| } |
| }); |
| renommerTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudRenommage; |
| if(noeuds.length > 0) { |
| noeudRenommage = noeuds[noeuds.length - 1]; |
| } else { |
| noeudRenommage = arbreMotsCles.getRootNode(); |
| } |
| renommerNoeud(noeudRenommage); |
| } |
| }); |
| ajouterTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudAjout; |
| if(noeuds.length > 0) { |
| noeudAjout = noeuds[noeuds.length - 1]; |
| } else { |
| noeudAjout = arbreMotsCles.getRootNode(); |
| } |
| ajouterNoeud(noeudAjout); |
| } |
| }); |
| supprimerTag.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for (int i = 0; i < noeuds.length; i++) { |
| supprimerNoeud(noeuds[i]); |
| } |
| } |
| }); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| demanderArbreMotsCles(this); |
| } |
| /** |
| * Supprime un noeud de l'arbre |
| * |
| * @param n |
| * le noeud à supprimer |
| */ |
| public void supprimerNoeud(TreeNode n) { |
| // si ça n'est pas la racine (qu'on ne peut pas supprimer) |
| if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) { |
| if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) { |
| // on détache le noeud et on le détruit |
| n.getParentNode().removeChild(n); |
| n.destroy(); |
| // puis on en notifie le médiateur en lui passant le noeud supprimé |
| // et l'arbre |
| surSuppressionMotCle(n, arbreMotsCles.getTree()); |
| } |
| } else { |
| // si l'utilisateur tente de supprimer la racine, on l'avertit de |
| // son erreur |
| Window.alert("Impossible de supprimer la racine de l'arbre"); |
| } |
| } |
| /** |
| * Ajoute un noeud dans l'arbre au parent donné |
| * |
| * @param parent |
| * le futur parent du noeud à ajouter |
| */ |
| public void ajouterNoeud(TreeNode parent) { |
| // on met l'ajout du noeud à vrai |
| ajoutNoeud = true; |
| // on crée un nouveau noeud vide |
| TreeNode nd = new TreeNode(""); |
| nd.setCls("x-view-treenode-keyword"); |
| nd.setChecked(true); |
| // on associe un objet au noeud qui contient des infos |
| String[] usObject = new String[2]; |
| // l'objet contient le nom du noeud |
| usObject[0] = ""; |
| usObject[1] = genererIdMotCle(nd); |
| nd.setId(usObject[1]); |
| nd.setUserObject(usObject); |
| // l'identifiant d'un noeud c'est son hashcode |
| // l'objet associé au noeud contient aussi son identifiant |
| // on le concatène au parent et on étend ses enfants |
| parent.appendChild(nd); |
| parent.expand(); |
| // enfin on place le curseur et on fait apparaitre le champ d'édition |
| // pour que l'utilisateur nomme son mot clé |
| te.startEdit(nd); |
| } |
| /** |
| * Renomme le noeud passé en paramètre |
| */ |
| public void renommerNoeud(TreeNode n) { |
| // TODO Auto-generated method stub |
| te.startEdit(n); |
| } |
| /** |
| * Coche le noeud s'il est décoché, le décoche sinon |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node) { |
| if (node.getUI().isChecked()) { |
| node.getUI().toggleCheck(false); |
| } else { |
| node.getUI().toggleCheck(true); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| public boolean execute(Node node) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .getUI().toggleCheck(false); |
| // on parcourt le tableau des mots clés |
| for (int i = 0; i < motsClesIds.length; i++) { |
| // si le mot clé fait partie des id à cocher on |
| // le coche |
| String usObject[] = (String[]) node |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| if (nodeId.equals(motsClesIds[i])) { |
| getArbreMotsCles().getNodeById(nodeId) |
| .getUI().toggleCheck(true); |
| getArbreMotsCles().getNodeById(nodeId).ensureVisible(); |
| return true; |
| } |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| } |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on coche les mots clés contenu dans le tableau |
| tableauMotsClesEnCours = (String[]) nouvelleDonnees; |
| if(this.isVisible()) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } else { |
| addListener(new WindowListenerAdapter() { |
| @Override |
| public void onShow(Component component) { |
| cocherMotsCles(tableauMotsClesEnCours); |
| } |
| }); |
| } |
| } |
| } |
| private String genererIdMotCle(TreeNode nd) { |
| return "" + (nd.hashCode() + (Math.random() * 10000)); |
| } |
| /** |
| * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
| * copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
| * |
| * @param ndPereOriginal |
| * le père des noeuds de l'arbre original |
| * @param ndPereCopie |
| * le père qui va recevoir les copies |
| */ |
| private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) { |
| if (ndPereCopie != null && ndPereOriginal != null) { |
| Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
| for (int i = 0; i < ndNodeFils.length; i++) { |
| String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
| TreeNode child = new TreeNode(usObj[0]); |
| child.setId(usObj[1]); |
| child.setChecked(false); |
| child.setUserObject(usObj); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| public void activerBoutonValider(boolean activer) { |
| valider.setVisible(activer); |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/GalerieImageVue.java |
|---|
| New file |
| 0,0 → 1,575 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import com.google.gwt.user.client.Element; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.XTemplate; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| 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.util.Format; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DataView; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.DataViewListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| /** |
| * Galerie d'images miniatures Avec barre de pagination |
| * |
| * @author aurelien |
| */ |
| public class GalerieImageVue extends Panel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * instance du médiateur |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Dataview, littéralement "vue de données" qui permet de définir la manière |
| * d'afficher les données |
| */ |
| private DataView dView = null; |
| /** |
| * Dataview, littéralement "vue de données" qui permet de définir la manière |
| * d'afficher les données |
| */ |
| private Store st = null; |
| /** |
| * Barre de pagination gérant l'affichage d'un nombre donné d'élements par |
| * page et la navigation entre eux |
| */ |
| private BarrePaginationVue pt = null; |
| /** |
| * Booleen indiquant si la galerie est instanciée ou pas |
| */ |
| private boolean estInstancie = false; |
| private boolean garderRatio = true; |
| private int tailleOr = 100 ; |
| boolean lienUploadInitialise = false ; |
| HTML videPanel = null ; |
| /** |
| * Constructeur sans argument, privé car ne doit pas être utilisé |
| */ |
| @SuppressWarnings("unused") |
| private GalerieImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur avec lequel la vue va communiquer |
| */ |
| public GalerieImageVue(ImageMediateur im) { |
| super("Galerie"); |
| iMediateur = im; |
| // on ajoute des listeners au composant tout entier |
| this.addListener(new ContainerListenerAdapter() { |
| // pour gagner du temps on n'instancie la vue en elle même que lors |
| // du premier affichage (lazy rendering) |
| @Override |
| public void onShow(Component component) { |
| if (!estInstancie) { |
| initialiser(); |
| } |
| } |
| }); |
| AjouterListenersLiens(); |
| // et on ajoute la tool bar |
| pt = new BarrePaginationVue(this); |
| pt.setLabelElement("Images"); |
| pt.setTaillePageParDefaut(50); |
| this.setBottomToolbar(pt); |
| } |
| /** |
| * Ajoute tous les listeners nécessaires à l'intercation utilisateur avec la |
| * vue de données |
| */ |
| public void ajouterListenersDataView() { |
| // ajout de listeners pour la gestion de la selection |
| // dans la galerie |
| dView.addListener(new DataViewListenerAdapter() { |
| // gestion du clic sur une image |
| @Override |
| public void onClick(DataView source, int index, Element node, |
| EventObject e) { |
| // on en notifie le médiateur |
| getIMediateur().clicGalerieImage(index, node, e); |
| } |
| // gestion du clic droit |
| @Override |
| public void onContextMenu(DataView source, int index, Element node, |
| EventObject e) { |
| // on stoppe l'évenement |
| e.stopEvent(); |
| // et on notifie le médiateur |
| getIMediateur().montrerContextMenu(e); |
| } |
| // gestion du double clic |
| @Override |
| public void onDblClick(DataView source, int index, Element node, |
| EventObject e) { |
| // on notife le mediateur |
| getIMediateur().clicGalerieImage(index, node, e); |
| } |
| // gestion des actions en fonction de la selection |
| @Override |
| public void onSelectionChange(DataView view, Element[] selections) { |
| // s'il n'y a aucun élement sélectionné |
| if (selections.length <= 0) { |
| // on en notifie le médiateur |
| getIMediateur().aucuneSelection(); |
| } else { |
| // sinon on notifie le médiateur |
| getIMediateur().selection(); |
| // et on lui demande de synchroniser la séléction avec les |
| // autres vues |
| getIMediateur().synchroniserSelection("galerie"); |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour la dataview |
| * |
| * @return la dataview |
| */ |
| public DataView getDView() { |
| return dView; |
| } |
| /** |
| * Renvoie les ids des images sélectionnées |
| * |
| * @return un tableau de String contenant les identifiants des images |
| * sélectionnées |
| */ |
| @Override |
| public String[] getIdSelectionnees() { |
| Record[] selection = getDView().getSelectedRecords(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("num_image"); |
| } |
| return id_selection; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Accesseur pour le store |
| * |
| * @return le store associé à la vue |
| */ |
| public Store getSt() { |
| return st; |
| } |
| /** |
| * Accesseur pour la toolbar |
| * |
| * @return la toolbar associée à la vue |
| */ |
| public BarrePaginationVue getToolBarVue() { |
| return pt; |
| } |
| /** |
| * Fonction d'initialisation du contenu (appelée lors du premier affichage |
| * de la liste) |
| */ |
| public void initialiser() { |
| // Preparation de la dataview et du template |
| // le template va créer une div contenant une image |
| // pour chacune des photos |
| final XTemplate template = new XTemplate( |
| new String[] { |
| "<tpl for='.'>", |
| "<div class='thumb-wrap' id='{num_image}'>", |
| "<div class='thumb dview-list'>{indication_transmission}{indication_liaison}<img class='miniature_galerie' src='{url_image_M}' width='{taille_x_s} px' height='{taille_y_s} px' title='{infobulle}' /></div>", |
| "<span class='info_image'>{nom_obs_associees_formatees}</span></div>", "</tpl>", |
| "<div class='x-clear'></div>" }); |
| // pour des raisons de performances on compile le template en une |
| // fonction |
| template.compile(); |
| // la dataview affichera les images en accord avec le template |
| // cree precedemment |
| dView = new DataView("div.thumb-wrap") { |
| @Override |
| public void prepareData(Data data) { |
| data.setProperty("shortName", Format.ellipsis(data |
| .getProperty("nom_original"), 15)); |
| int[] XY = {data.getPropertyAsInt("taille_x") ,data.getPropertyAsInt("taille_y")} ; |
| int[] XYresize ; |
| if(garderRatio) { |
| XYresize = calculerDimensions(XY); |
| } |
| else { |
| XYresize = new int[2] ; |
| XYresize[0] = XYresize[1] = tailleOr ; |
| } |
| data.setProperty("taille_x_s", XYresize[0]); |
| data.setProperty("taille_y_s", XYresize[1]); |
| String nomObs = data.getProperty("obs_associees"); |
| String htmltransmis = ""; |
| String htmllie = ""; |
| boolean associee = estAssocieeTransmise(nomObs)[0]; |
| boolean transmise = estAssocieeTransmise(nomObs)[1]; |
| String nomFormate = getNomsObservationsFormatees(nomObs); |
| if(associee) { |
| htmllie = "<img class='picto_haut_droite' src='chain.png' />"; |
| } |
| if(transmise) { |
| htmltransmis = "<img class='picto_haut_gauche' src='tela.png' />"; |
| } |
| data.setProperty("infobulle", nomFormate); |
| data.setProperty("indication_transmission", htmltransmis); |
| data.setProperty("indication_liaison", htmllie); |
| data.setProperty("nom_obs_associees_formatees", nomFormate); |
| } |
| }; |
| dView.setTpl(template); |
| // parametre d'affichage de la dataview |
| this.setAutoScroll(true); |
| dView.setAutoHeight(true); |
| dView.setMultiSelect(true); |
| dView.setOverCls("x-view-over"); |
| dView.setEmptyText(""); |
| // creation du store |
| FieldDef defNumImage = new IntegerFieldDef("num_image"); |
| FieldDef defNomImage = new StringFieldDef("nom_original"); |
| FieldDef defDatImage = new StringFieldDef("dat_image"); |
| FieldDef defLieImage = new StringFieldDef("lie_image"); |
| FieldDef defAppImage = new StringFieldDef("app_image"); |
| FieldDef defUrlImageS = new StringFieldDef("url_image_S"); |
| FieldDef defUrlImageM = new StringFieldDef("url_image_M"); |
| FieldDef defUrlImage = new StringFieldDef("url_image"); |
| FieldDef defTailleX = new IntegerFieldDef("taille_x"); |
| FieldDef defTailleY = new IntegerFieldDef("taille_y"); |
| FieldDef defObsAssociees = new StringFieldDef("obs_associees"); |
| FieldDef[] defTab = { defNumImage, defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage,defTailleX,defTailleY, defObsAssociees}; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| dView.setStore(st); |
| this.getDView().setLoadingText("chargement"); |
| this.add(dView); |
| dView.hide(); |
| videPanel = new HTML("<div class=\"avertissement\" >Aucune image à afficher. <br/> <a id=\"lienUploadMultiple\" href=\"#\" > Cliquez ici pour ajouter un dossier entier ou plusieurs fichiers </a> (nécessite Java) <br/> " + |
| " <a id=\"lienUploadSimple\" href=\"#\" > Cliquez ici pour ajouter un fichier à la fois </a> <br/> " + |
| " Pour ajouter des images plus tard, allez dans le menu Fichier -> Ajouter des images </div>"); |
| this.add(videPanel); |
| // ajouts de la gestion des evenements pour la dataview |
| configDragAndDrop() ; |
| ajouterListenersDataView(); |
| estInstancie = true ; |
| } |
| 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 les données proviennent 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"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si l'objet reçu est un store |
| if (nouvelleDonnees instanceof Store) { |
| st = (Store) nouvelleDonnees; |
| if(st.getCount() != 0) { |
| // on le charge |
| st.load(); |
| if(videPanel != null && videPanel.isVisible()) { |
| videPanel.setVisible(false) ; |
| } |
| if(dView != null) { |
| if(!dView.isVisible()) { |
| dView.setVisible(true); |
| } |
| // on l'affecte à la vue |
| dView.setStore(st); |
| // et on rafrachit la vue |
| dView.refresh(); |
| } |
| } |
| else |
| { |
| st.removeAll(); |
| st.load(); |
| dView.setStore(st); |
| if(dView.isVisible()) { |
| dView.hide() ; |
| } |
| if(videPanel != null && !videPanel.isVisible()) { |
| videPanel.setVisible(true); |
| AjouterListenersLiens(); |
| } |
| } |
| } |
| // si le composant doit répandre le rafraichissement |
| if (repandreRafraichissement) { |
| // il en notifie le médiateur en lui donnant une copie des données |
| // et en notifiant qu'il en est l'expéditeur |
| getIMediateur().synchroniserDonneesZoomListeGalerie( |
| nouvelleDonnees, this); |
| } |
| } |
| /** |
| * Méthode héritée de l'interface VueListable Sélectionne les images dans la |
| * galerie suivant les identifiants donnés en paramètres |
| * |
| * @param ids |
| * les identifiants des images à sélectionner |
| */ |
| public void selectionnerImages(int[] ids) { |
| getDView().select(ids); |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) { |
| iMediateur.changerTaillePage(nouvelleTaillePage) ; |
| } |
| public int[] calculerDimensions(int[] tailleXY) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = this.tailleOr ; |
| 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; |
| } |
| private void AjouterListenersLiens() { |
| addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| ExtElement uploadS = Ext.get("lienUploadSimple"); |
| uploadS.removeAllListeners(); |
| uploadS.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(false); |
| } |
| }) ; |
| ExtElement uploadM = Ext.get("lienUploadMultiple"); |
| uploadM.removeAllListeners(); |
| uploadM.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| getIMediateur().uploaderImages(true); |
| } |
| }); |
| } |
| }); |
| } |
| 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 |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/ImageMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,96 |
| 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.user.client.ui.HTML; |
| import com.gwtext.client.widgets.Panel; |
| /** |
| * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots |
| * clés cochables et réorganisables à volonté |
| * |
| * @author aurelien |
| * |
| */ |
| public class ImageMotsClesVue extends Panel implements Rafraichissable { |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| private String[] tableauMotsClesEnCours = new String[0]; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| private HTML motsClesAffiches = new HTML(); |
| /** |
| * Constructeur sans paramètre (privé car interdit d'utilisation) |
| */ |
| @SuppressWarnings("unused") |
| private ImageMotsClesVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ImageMotsClesVue(ImageMediateur im) { |
| // on crée le panel |
| super("Mots clés"); |
| this.setHeight("100%"); |
| this.add(motsClesAffiches); |
| motsClesAffiches.setHeight("100%"); |
| this.setBorder(false); |
| this.setBodyBorder(false); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on affiche les mots clés contenu dans le tableau |
| tableauMotsClesEnCours = (String[]) nouvelleDonnees; |
| afficherMotsCles(tableauMotsClesEnCours); |
| } |
| } |
| private void afficherMotsCles(String[] tableauMotsClesEnCours) { |
| motsClesEnCours = "<ul class=\"liste_mots_cles\">"; |
| for (int i = 0; i < tableauMotsClesEnCours.length; i++) { |
| if(!tableauMotsClesEnCours[i].trim().isEmpty()) { |
| motsClesEnCours += "<li>"+tableauMotsClesEnCours[i]+"</li>"; |
| } |
| } |
| motsClesEnCours += "</ul>"; |
| motsClesAffiches.setHTML(motsClesEnCours); |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/MenuIdVue.java |
|---|
| New file |
| 0,0 → 1,85 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| 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; |
| public class MenuIdVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour le changement d'utilisateur |
| */ |
| private Item changerId = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuIdVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuIdVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| // on construit le menu |
| changerId = new Item("Changer d'utilisateur"); |
| addItem(changerId); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la recherche par commentaires |
| if (item.equals(changerId)) { |
| // on notifie le médiateur |
| getIMediateur().afficherMenuId(); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/OptionsImages.java |
|---|
| New file |
| 0,0 → 1,211 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| 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.MenuItem; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Menu de gestion des images |
| * |
| * @author aurelien |
| * |
| */ |
| public class OptionsImages { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour l'upload |
| */ |
| private MenuItem uploaderImage = null; |
| /** |
| * Item pour la suppression |
| */ |
| private ToolbarButton supprimerImage = null; |
| /** |
| * Item pour l'ajout d'images à la selection |
| */ |
| private Item ajouterImageSelection = null; |
| /** |
| * Item pour vider la selection d'images |
| */ |
| private Item viderSelection = null; |
| /** |
| * Item pour lier la selection d'images |
| */ |
| private Item afficherSelection = null; |
| private Item uploadMultiple = null ; |
| private Item uploadSimple = null ; |
| private Menu mnFichiers = null ; |
| private Menu mnTampon = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private OptionsImages() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public OptionsImages(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| mnFichiers = new Menu(); |
| uploadMultiple = new Item("Plusieurs dossiers ou fichiers à la fois"); |
| uploadSimple = new Item("Un fichier à la la fois"); |
| mnFichiers.addItem(uploadMultiple); |
| mnFichiers.addItem(uploadSimple); |
| // on construit le menu |
| uploaderImage = new MenuItem("Ajouter des images", mnFichiers); |
| supprimerImage = new ToolbarButton("Supprimer"); |
| ajouterImageSelection = new Item( |
| "Ajouter les images sélectionnées au tampon"); |
| viderSelection = new Item("vider le contenu du tampon"); |
| afficherSelection = new Item("Supprimer le contenu du tampon"); |
| mnTampon = new Menu(); |
| mnTampon.addItem(ajouterImageSelection); |
| mnTampon.addItem(viderSelection); |
| mnTampon.addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| mnTampon.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'ajout à la sélection |
| if (item.equals(ajouterImageSelection)) { |
| getIMediateur().ajouterImagesSelection(); |
| } |
| // si c'est le vidage de la sélection |
| if (item.equals(viderSelection)) { |
| getIMediateur().viderSelection(); |
| } |
| // si c'est l'affichage de la selection |
| if (item.equals(afficherSelection)) { |
| getIMediateur().afficherIdSelectionImages(); |
| } |
| // enfin, on cache le menu |
| mnTampon.hide(); |
| } |
| @Override |
| public void onShow(Menu menu) { |
| if(getIMediateur().getCompteSelection() != 0) { |
| afficherSelection.enable(); |
| viderSelection.enable(); |
| } |
| else { |
| afficherSelection.disable(); |
| viderSelection.disable(); |
| } |
| } |
| }); |
| mnTampon.setTitle("Permet de sélectionner et d'afficher des images présentes sur plusieurs pages"); |
| // si c'est la suppression |
| supprimerImage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| // on notifie le médiateur |
| getIMediateur().supprimerImages(); |
| } |
| }); |
| supprimerImage.setTitle("Supprimer les images sélectionnées"); |
| mnFichiers.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'upload |
| if (item.equals(uploadMultiple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(true); |
| } |
| // si c'est l'upload |
| if (item.equals(uploadSimple)) { |
| // on notifie le médiateur |
| getIMediateur().uploaderImages(false); |
| } |
| } |
| }); |
| mnFichiers.setTitle("Ajouter des images en les selectionnant une par une ou bien un dossier à la fois"); |
| } |
| public Menu getMenuImage() { |
| return mnFichiers; |
| } |
| public Menu getMenuTampon() { |
| return mnTampon; |
| } |
| public ToolbarButton getBoutonSuppression() { |
| return supprimerImage; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/ListeImageVue.java |
|---|
| New file |
| 0,0 → 1,745 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.Record; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| 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.Component; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.grid.CellMetadata; |
| import com.gwtext.client.widgets.grid.ColumnConfig; |
| import com.gwtext.client.widgets.grid.ColumnModel; |
| import com.gwtext.client.widgets.grid.GridDragData; |
| import com.gwtext.client.widgets.grid.GridPanel; |
| import com.gwtext.client.widgets.grid.Renderer; |
| import com.gwtext.client.widgets.grid.RowSelectionModel; |
| import com.gwtext.client.widgets.grid.event.GridRowListener; |
| import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter; |
| /** |
| * Liste d'image composée de miniatures et d'information sur l'image, implémente |
| * l'interface rafraichissable et l'interface vueListable |
| * |
| * @author aurelien |
| */ |
| public class ListeImageVue extends GridPanel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur = null; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig numImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig transmisImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig urlImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig lieImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig datImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig appImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig noteImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomImage; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig obsAssociees; |
| /** |
| * Modele de colonnes |
| */ |
| private ColumnModel modeleColonnes; |
| /** |
| * Booleen d'instanciation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * Store qui contient les données à afficher |
| */ |
| private Store st = null; |
| /** |
| * Configuration des colonnes du store |
| */ |
| private ColumnConfig cl = null; |
| /** |
| * Barre de pagination |
| */ |
| private BarrePaginationVue bt = null; |
| /** |
| * Taille max des images dans la liste |
| */ |
| private int tailleOr = 50 ; |
| /** |
| * Garder ou non l'aspet original des images |
| */ |
| private boolean garderRatio = true; |
| /** |
| * Constructeur sans arguments (privé car ne doit pas être utilisé) |
| */ |
| private ListeImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ListeImageVue(ImageMediateur im) { |
| new ListeImageVue(); |
| this.setId("listeImageGrid"); |
| // on associe le médiateur |
| this.iMediateur = im; |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Images"); |
| bt.setTaillePageParDefaut(50); |
| setBottomToolbar(bt); |
| // on construit le modèle de colonnes |
| numImage = new ColumnConfig("Numéro", "num_image", 30, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String ImgNum = record.getAsString("num_image"); |
| return "<div class=\"centered-list\">" + ImgNum |
| + "</div>"; |
| } |
| }); |
| transmisImage = new ColumnConfig(" ", "obs_associees", 10, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String nomObs = record.getAsString("obs_associees"); |
| if(nomObs == null) { |
| return ""; |
| } |
| boolean transmise = estAssocieeTransmise(nomObs)[1]; |
| if(transmise) |
| { |
| return "<img src=\"tela.png\"/></img>" ; |
| } |
| else |
| { |
| return "" ; |
| } |
| } |
| }); |
| datImage = new ColumnConfig("Date", "dat_image", 80, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String ImgDat = record.getAsString("dat_image"); |
| if (ImgDat == null) { |
| ImgDat = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgDat |
| + "</div>"; |
| } |
| }); |
| lieImage = new ColumnConfig("Lieu", "lie_image", 120, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String ImgLie = record.getAsString("lie_image"); |
| if (ImgLie == null) { |
| ImgLie = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgLie |
| + "</div>"; |
| } |
| }); |
| appImage = new ColumnConfig("Appareil", "app_image", 120, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String ImgApp = record.getAsString("app_image"); |
| if (ImgApp == null) { |
| ImgApp = " "; |
| } |
| return "<div class=\"centered-list\">" + ImgApp |
| + "</div>"; |
| } |
| }); |
| // la colonne url possède une méthode de rendu spéciale |
| urlImage = new ColumnConfig("Image", "url_image_S", 30, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| // on affiche une div contenant l'image pointée par |
| // l'url |
| int[] XY = {record.getAsInteger("taille_x") ,record.getAsInteger("taille_y")} ; |
| int[] XYresize = {tailleOr,tailleOr} ; |
| if(garderRatio) { |
| XYresize = calculerDimensions(XY); |
| } |
| String ImgUrl = record.getAsString("url_image_S"); |
| String ImgNum = record.getAsString("num_image"); |
| return "<div class=\"img-list centered-list\"> <img src=\"" |
| + ImgUrl + "\" title='" + ImgNum + "' width=\""+XYresize[0]+" px\" height=\""+XYresize[1]+" px\"> </div>"; |
| } |
| }); |
| noteImage = new ColumnConfig("Note", "note_image", 80, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String htmlImage = ""; |
| int noteImg = record.getAsInteger("note_image"); |
| if (noteImg >= 0) { |
| htmlImage += "<div class=\"img-note centered-list\">"; |
| for (int i = 0; i <= noteImg; i++) { |
| htmlImage += "<img src=\"note-on.gif\">"; |
| } |
| htmlImage += "</div>"; |
| } |
| return htmlImage; |
| } |
| }); |
| nomImage = new ColumnConfig("Nom original", "nom_original", 120, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String imgNomOr = record.getAsString("nom_original"); |
| if (imgNomOr == null) { |
| imgNomOr = " "; |
| } |
| return "<div class=\"centered-list\">" + imgNomOr |
| + "</div>"; |
| } |
| }); |
| obsAssociees = new ColumnConfig("Nom associé", "obs_associees", 80, true, |
| new Renderer() { |
| @Override |
| public String render(Object value, |
| CellMetadata cellMetadata, Record record, |
| int rowIndex, int colNum, Store store) { |
| cellMetadata.setCssClass("centered-list"); |
| String nomObs = record.getAsString("obs_associees"); |
| if(nomObs == null) { |
| return ""; |
| } |
| String nomFormate = getNomsObservationsFormatees(nomObs); |
| return "<div class=\"centered-list\">" + nomFormate |
| + "</div>"; |
| } |
| }); |
| // on associe le modèle de colonnes |
| ColumnConfig[] cm = { numImage, transmisImage, urlImage, obsAssociees, datImage, lieImage, appImage, |
| noteImage,nomImage} ; |
| modeleColonnes = new ColumnModel(cm); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setAutoWidth(true); |
| this.setEnableColumnResize(true); |
| // creation du store |
| FieldDef defNumImage = new IntegerFieldDef("num_image"); |
| FieldDef defTransmisImage = new IntegerFieldDef("obs_associees"); |
| FieldDef defNomImage = new StringFieldDef("nom_original"); |
| FieldDef defDatImage = new StringFieldDef("dat_image"); |
| FieldDef defLieImage = new StringFieldDef("lie_image"); |
| FieldDef defAppImage = new StringFieldDef("app_image"); |
| FieldDef defUrlImageS = new StringFieldDef("url_image_S"); |
| FieldDef defUrlImageM = new StringFieldDef("url_image_M"); |
| FieldDef defUrlImage = new StringFieldDef("url_image"); |
| FieldDef defNoteImage = new StringFieldDef("note_image"); |
| FieldDef defTailleX = new IntegerFieldDef("taille_x"); |
| FieldDef defTailleY = new IntegerFieldDef("taille_y"); |
| FieldDef defObsAssociees = new StringFieldDef("obs_associees"); |
| FieldDef[] defTab = { defNumImage,defTransmisImage, defNomImage, defDatImage, defLieImage, |
| defAppImage, defUrlImageS, defUrlImageM, defUrlImage, |
| defNoteImage, defTailleX, defTailleY, defObsAssociees}; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| this.getView().setAutoFill(true); |
| // on crée un masque de chargement qui s'affichera lors des mises à jour |
| this.setLoadMask("chargement"); |
| //Enable drag and drop |
| this.setEnableDragDrop(true); |
| //You need to set the same group for both grids |
| this.setDdGroup("DragGroupName"); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onHide(Component component) { |
| } |
| // lors du premier rendu on demande les données qui sont déjà |
| // contenues dans la galerie qui est le premier élément affiché |
| @Override |
| public void onRender(Component component) { |
| if (!isEstInstancie()) { |
| setEstInstancie(true); |
| setDragDropText("Glissez les images sur la liste d'observation pour les lier") ; |
| getIMediateur().synchroniserSelection("galerie"); |
| } |
| } |
| @Override |
| public void onShow(Component component) { |
| } |
| }); |
| this.addGridRowListener(new GridRowListener() { |
| // gestion du clic sur une ligne |
| @Override |
| public void onRowClick(GridPanel grid, int rowIndex, EventObject e) { |
| // on notifie le médiateur et on lui passe le numéro de ligne |
| getIMediateur().clicListeImage(rowIndex); |
| } |
| // gestion du clic droit |
| @Override |
| public void onRowContextMenu(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on stoppe l'évenement pour empecher le navigateur d'afficher |
| // son propre menu |
| e.stopEvent(); |
| // on notifie le médiateur en lui passant l'évenement |
| getIMediateur().montrerContextMenu(e); |
| } |
| // gestion du double clic |
| @Override |
| public void onRowDblClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur en lui passant le numéro de ligne |
| getIMediateur().doubleClicListeImage(rowIndex); |
| } |
| }); |
| this.getSelectionModel().addListener(new RowSelectionListenerAdapter() { |
| // gestion de la sélection |
| @Override |
| public void onSelectionChange(RowSelectionModel sm) { |
| // si on a rien de sélectionné |
| if (sm.getCount() <= 0) { |
| // on notifie le médiateur (qui désactive notamment l'accès |
| // à certaines infos) |
| getIMediateur().aucuneSelection(); |
| } else { |
| // sinon on notifie le médiateur |
| getIMediateur().selection(); |
| // et on lui demande de synchroniser la selection avec les |
| // autres vues |
| getIMediateur().synchroniserSelection("liste"); |
| } |
| } |
| }); |
| //Enable drag and drop |
| this.setEnableDragDrop(true); |
| //Same name in destination |
| this.setDdGroup("DragGroupName"); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("DragGroupName"); |
| //Now this is the important part, you need a drop target |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| @Override |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| if(data instanceof GridDragData) |
| { |
| GridDragData gdd = (GridDragData)data ; |
| if(gdd.getGrid().getId().equals("listeImageGrid")) |
| { |
| return false ; |
| } |
| else |
| { |
| return iMediateur.lierObsDD(source, e, data, getId()) ; |
| } |
| } |
| else |
| { |
| return false ; |
| } |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| return "x-dd-drop-ok"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface VueListable Sélectionne les images dans la |
| * galerie suivant les identifiants donnés en paramètres |
| */ |
| @Override |
| public String[] getIdSelectionnees() { |
| Record[] selection = this.getSelectionModel().getSelections(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("num_image"); |
| } |
| return id_selection; |
| } |
| /** |
| * Accesseur pour la config de colonnes |
| * |
| * @return la config de colonnes |
| */ |
| public ColumnConfig getCl() { |
| return cl; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| /** |
| * Accesseur pour le modèle de colonnes |
| * |
| * @return le modèle de colonnes |
| */ |
| public ColumnModel getModeleColonnes() { |
| return modeleColonnes; |
| } |
| /** |
| * Accesseur pour le store |
| * |
| * @return le store contenant les données |
| */ |
| public Store getSt() { |
| return st; |
| } |
| /** |
| * Accesseur pour le booleen d'instanciation |
| * |
| * @return le booleen d'instanciation |
| */ |
| public boolean isEstInstancie() { |
| return estInstancie; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen de notification du rafraichissement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit un store |
| if (nouvelleDonnees instanceof Store) { |
| // on affecte celui-ci comme gestionnaire de données |
| st = (Store) nouvelleDonnees; |
| st.load(); |
| // et on reconfigure et rafraichit la vue |
| this.reconfigure(st, this.getColumnModel()); |
| } |
| // si on doit répandre l'évenement |
| if (repandreRafraichissement) { |
| // on notifie le médiateur avec une copie des données |
| getIMediateur().synchroniserDonneesZoomListeGalerie( |
| nouvelleDonnees, this); |
| } |
| } |
| /** |
| * Sélectionne des enregistrements donné |
| * |
| * @param sel |
| * un tableau d'enregistrement à selectionner |
| */ |
| public void selectionnerEnregistrements(Record[] sel) { |
| if (isEstInstancie()) { |
| getSelectionModel().clearSelections(); |
| getSelectionModel().selectRecords(sel); |
| } |
| } |
| /** |
| * Accesseur pour la toolbar de pagination |
| * |
| * @return la toolbar de pagination |
| */ |
| public BarrePaginationVue getToolBarVue() { |
| return bt; |
| } |
| /** |
| * Setteur pour le booleen d'instanciation |
| * |
| * @param estInstancie |
| * la nouvelle valeur du booleen |
| */ |
| public void setEstInstancie(boolean estInstancie) { |
| this.estInstancie = estInstancie; |
| } |
| public void mettreAjourInfos(String commentaires, String date, String note) { |
| for (int i = 0; i < getSelectionModel().getCount(); i++) { |
| getSelectionModel().getSelections()[i].set("note_image", note); |
| getSelectionModel().getSelections()[i].set("dat_image", date); |
| } |
| } |
| @Override |
| public void changerNumeroPage(int pageCourante) { |
| iMediateur.changerNumeroPage(pageCourante) ; |
| } |
| @Override |
| public void changerTaillePage(int nouvelleTaillePage) { |
| iMediateur.changerTaillePage(nouvelleTaillePage) ; |
| } |
| public int[] calculerDimensions(int[] tailleXY) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = this.tailleOr ; |
| 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; |
| } |
| 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 |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/image/MenuLiaisonVue.java |
|---|
| New file |
| 0,0 → 1,149 |
| package org.tela_botanica.client.vues.image; |
| import org.tela_botanica.client.image.ImageMediateur; |
| 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; |
| import com.gwtext.client.core.EventObject;; |
| /** |
| * Menu de gestion des images |
| * |
| * @author aurelien |
| * |
| */ |
| public class MenuLiaisonVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ImageMediateur iMediateur; |
| /** |
| * Item pour lier la selection d'images aux observations selectionnées |
| */ |
| private Item lierSelection = null ; |
| /** |
| * Item pour lier la selection d'images aux observations selectionnées |
| */ |
| private Item lierSelectionTampon = null ; |
| /** |
| * Item pour afficher la selection d'images |
| */ |
| private Item afficherSelection = null; |
| /** |
| * Item pour supprimer la liaison entre une observation et une image |
| */ |
| private Item supprimerLiaison = null ; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuLiaisonVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuLiaisonVue(ImageMediateur im) { |
| super(); |
| iMediateur = im; |
| lierSelection = new Item("Lier les images selectionnées à la sélection d'observation"); |
| lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(lierSelectionTampon); |
| addItem(afficherSelection); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| public MenuLiaisonVue(ImageMediateur im, boolean liaison) { |
| iMediateur = im; |
| lierSelection = new Item("Lier les images selectionnées à la sélection d'observation"); |
| lierSelectionTampon = new Item("Lier le tampon à la sélection d'observation"); |
| afficherSelection = new Item("Afficher le tampon"); |
| addItem(lierSelection); |
| addItem(lierSelectionTampon); |
| addItem(afficherSelection); |
| iMediateur = im; |
| if(liaison) { |
| supprimerLiaison = new Item("Supprimer la liaison") ; |
| addItem(supprimerLiaison); |
| } |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(lierSelection)) { |
| // on notifie le médiateur |
| getIMediateur().LierObservations(); |
| } |
| // si c'est la suppression |
| if (item.equals(lierSelectionTampon)) { |
| // on notifie le médiateur |
| getIMediateur().LierTamponObservations(); |
| } |
| // si c'est la liaison |
| if (item.equals(afficherSelection)) { |
| getIMediateur().afficherIdSelectionImages(); |
| } |
| if(item.equals(supprimerLiaison)) { |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ImageMediateur getIMediateur() { |
| return iMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |