| /trunk/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,207 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextArea; |
| public class SaisieMotsClesVue extends Window implements Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAAjouter = "" ; |
| private int nbMotsClesMax = 1 ; |
| private TextArea motsClesAjout = null; |
| private Button validerAjout = null ; |
| private Button voirCacherNuage = null; |
| private boolean nuageVisible = false ; |
| private Panel contenuNuage = null ; |
| public SaisieMotsClesVue(ObservationMediateur om) { |
| super("Entrez vos mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| //setWidth(300); |
| motsClesAjout = new TextArea(); |
| //motsClesAjout.setWidth(300); |
| validerAjout = new Button("Valider"); |
| voirCacherNuage= new Button("Afficher les mots clés"); |
| final Rafraichissable r = this ; |
| this.setCloseAction(CLOSE); |
| validerAjout.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| motsAAjouter = motsClesAjout.getText(); |
| //oMediateur.AjouterMotsClesEnMasse(motsAAjouter); |
| } |
| }); |
| voirCacherNuage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(nuageVisible) { |
| if(contenuNuage != null) { |
| contenuNuage.clear(); |
| } |
| voirCacherNuage.setText("Afficher les mots clés"); |
| nuageVisible = false; |
| } |
| else { |
| // oMediateur.obtenirNuageMotsCles(r); |
| voirCacherNuage.setText("Cacher les mots clés"); |
| nuageVisible = true; |
| } |
| } |
| }); |
| add(motsClesAjout); |
| add(validerAjout); |
| add(voirCacherNuage); |
| contenuNuage = new Panel(); |
| contenuNuage.setBorder(false); |
| add(contenuNuage); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof String) { |
| String res = (String)nouvelleDonnees; |
| if(res.equals("OK")) { |
| masquerChargement(); |
| oMediateur.obtenirListeObservation(); |
| //oMediateur.obtenirNuageMotsCles(this); |
| } |
| } |
| } |
| private void construireNuage() { |
| contenuNuage.clear(); |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| public void onBrowserEvent(Event e) { |
| motsAAjouter += " "+e.getTarget().getInnerHTML(); |
| motsClesAjout.setValue(motsAAjouter); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| contenuNuage.add(contenuHTML); |
| contenuNuage.doLayout(); |
| doLayout(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
|---|
| New file |
| 0,0 → 1,520 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| 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; |
| public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private static 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; |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| /** |
| * 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 sans paramètre (privé car interdit d'utilisation) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreMotsClesObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreMotsClesObservationVue(ObservationMediateur om) { |
| // on crée le panel |
| super("Mots clés"); |
| this.setLayout(new VerticalLayout()); |
| oMediateur = om; |
| // 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-obs"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Tags"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Mots clés", "racine" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| // arbreMotsCles.setWidth(500); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| valider = new Button("Appliquer"); |
| arbreMotsCles.add(te); |
| // on met en forme le layout |
| this.add(arbreMotsCles); |
| this.add(valider); |
| this.setBorder(false); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Acesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| private ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| /** |
| * 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; |
| } |
| /** |
| * Ajoute les listeners nécessaires pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| arbreMotsCles.addListener(new TreePanelListenerAdapter() { |
| // gestion du clic sur un noeud |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| gererClicNoeud(node); |
| } |
| // gestion du clic droit sur un noeud |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| getOMediateur().montrerContextMenuArbre(node, e, getTe()); |
| } |
| // gestion du double clic sur un noeud |
| public void onDblClick(TreeNode node, EventObject e) { |
| modifNoeud = true; |
| if (!node.getId().equals("racine_obs")) { |
| te.startEdit(node); |
| } |
| } |
| // gestion de la modification du texte d'un noeud |
| public void onTextChange(TreeNode node, String text, String oldText) { |
| // 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 notifie le médiateur de l'ajout et on lui passe |
| // l'arbre |
| getOMediateur().ajouterMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| // et considère l'ajout achevé |
| ajoutNoeud = false; |
| } |
| // si c'est noeud déjà existant |
| else { |
| if (modifNoeud) { |
| // on notifie le médiateur de la modification et on lui |
| // passe l'arbre |
| getOMediateur().modifierMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| // et on considère la modification achevée |
| modifNoeud = false; |
| } |
| } |
| } |
| // gestion du déplacement d'un noeud |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| getOMediateur().deplacerMotCleDansArbre(node, |
| getArbreMotsCles().getTree()); |
| } |
| }); |
| // gestion de la validation |
| valider.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| 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 |
| 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(); |
| getOMediateur().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 |
| getOMediateur().mettreAjourMotsCles(motsClesEnCours, |
| arbreMotsCles.getTree()); |
| } |
| }); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| getOMediateur().obtenirArbreMotsCles(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())) { |
| // 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 |
| getOMediateur() |
| .supprimerMotCleDansArbre(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); |
| } |
| /** |
| * 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 |
| 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+"_obs") |
| .getUI().toggleCheck(true); |
| return true; |
| } |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| else { |
| motsClesEnAttente = motsClesIds ; |
| } |
| } |
| /** |
| * 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 |
| */ |
| 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; |
| } |
| // s'il y a des mots clés en attente (lors du premier rendering) |
| if (motsCleInitialises == false && motsClesEnAttente != null) { |
| // on les coche |
| // cocherMotsCles(motsClesEnAttente) ; |
| motsCleInitialises = true; |
| } |
| if(motsClesEnAttente.length > 0) { |
| cocherMotsCles(motsClesEnAttente); |
| } |
| } |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle image) |
| if (nouvelleDonnees instanceof String[]) { |
| // et que l'arbre est instancié |
| if (arbreCharge) { |
| // 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 |
| String[] motsClesIds = (String[]) nouvelleDonnees; |
| cocherMotsCles(motsClesIds); |
| } |
| // si l'arbre n'est pas encore instancié on met les mots clés en |
| // attente |
| else { |
| motsClesEnAttente = (String[]) nouvelleDonnees; |
| } |
| } |
| } |
| 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] +"_obs"); |
| child.setChecked(false); |
| child.setUserObject(usObj); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,562 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| 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; |
| /** |
| * Arbre Filtrant sur les entites geographiques |
| * |
| * |
| * @author aurelien + david |
| * |
| */ |
| public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String entitesGeographiquesEncours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreEntitesGeographiques = null; |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreEntiteGeographiqueObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super("Localités"); |
| this.observationMediateur = obs; |
| arbreEntitesGeographiques = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| this.addListener(new PanelListenerAdapter() { |
| // on instancie réellement les composants au moment du rendu pour |
| // accélérer l'affichage |
| // et éviter des bugs |
| public void onRender(Component component) { |
| // on interdit le drag and drop dans l'arbre |
| arbreEntitesGeographiques.setEnableDD(false); |
| arbreEntitesGeographiques.setId("x-view-tree-filter-entity"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Localités"); |
| root.setId("racine_entite"); |
| String[] usObject = { "Localités" }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.setRootVisible(true); |
| arbreEntitesGeographiques.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreEntitesGeographiques); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() { |
| public void onClick(TreeNode node, EventObject e) { |
| nomFiltre = "" ; |
| entitesGeographiquesEncours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| String nomArriereGrandPere = ""; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(!arbreCharge) |
| { |
| arbreEntitesGeographiques.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| return ; |
| case 4: nomFiltre += "station,lieudit,location,id_location"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ; |
| break; |
| case 3: nomFiltre += "lieudit,location,id_location"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ; |
| break; |
| case 2: nomFiltre += "location,id_location"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere ; |
| break; |
| case 1: nomFiltre += "id_location"; |
| entitesGeographiquesEncours += node.getText() ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| // Le filtre est modifie : on lance un rafraaaichissement de la liste des observations affichees |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| }) ; |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| entitesGeographiquesEncours = ""; |
| arbreEntitesGeographiques.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) { |
| ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ; |
| // on crée un arbre vide |
| Tree nouvelArbre = new Tree() ; |
| TreeNode root = new TreeNode(); |
| root.setId("racine_entite"); |
| root.setText("Localités"); |
| String[] usObjRoot = { "Localités"}; |
| root.setUserObject(usObjRoot); |
| nouvelArbre.setRootNode(root); |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() { |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next()); |
| creerHierarchieNoeud(nouvelArbre ,root, ent); |
| doLayout(); |
| } |
| copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode()); |
| arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ; |
| // 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() ; |
| arbreEntitesGeographiques.doLayout(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // Cas d'ajout unitaire d'une observation |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation obs = (Observation)nouvelleDonnees ; |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation()); |
| creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent); |
| doLayout(); |
| arbreEntitesGeographiques.doLayout() ; |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreEntitesGeographiques; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Localités"; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ; |
| 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(""+usObj[1]); |
| 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) |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| public int compare(TreeNode o1, TreeNode o2) { |
| if(o1.getText().equals("Inconnue")) { |
| return -1 ; |
| } |
| if(o2.getText().equals("Inconnue")) { |
| return 1 ; |
| } |
| if(o1.getDepth() == 1 && o2.getDepth() == 1) |
| { |
| String l1 = o1.getText() ; |
| String l2 = o2.getText() ; |
| if(l1.length() == 1) { |
| l1 = "0"+l1; |
| } |
| if(l2.length() == 1) { |
| l2 = "0"+l2; |
| } |
| Integer n1 = 0; |
| Integer n2 = 0; |
| try{ |
| n1 = Integer.parseInt(l1) ; |
| n2 = Integer.parseInt(l2) ; |
| } catch(NumberFormatException ne) { |
| n1 = 0; |
| n2 = 0; |
| } |
| return n1.compareTo(n2) ; |
| } |
| else |
| { |
| String n1 = o1.getId() ; |
| String n2 = o2.getId() ; |
| return n1.compareToIgnoreCase(n2); |
| } |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreEntitesGeographiques.collapseAll(); |
| arbreEntitesGeographiques.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Localités"); |
| root.setId("racine_entite"); |
| String[] usObject = { "Localités" }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| entitesGeographiquesEncours = ""; |
| } |
| private TreeNode creerNoeud(String id, String texte) { |
| TreeNode nouveauNoeud = new TreeNode(); |
| nouveauNoeud.setId(""+(id)); |
| nouveauNoeud.setText(texte); |
| String[] usObj = {texte,id+""}; |
| nouveauNoeud.setUserObject(usObj); |
| return nouveauNoeud; |
| } |
| /** |
| * |
| * @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds |
| * @param root le noeud racine auquel on concatène la hierarchie crée |
| * @param ent l'entité géographique qui doit être décomposée en arborescence |
| * @return |
| */ |
| private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) { |
| String idLocation=null; |
| String location=null; |
| String lieuDit=null; |
| String station=null; |
| idLocation=ent.getIdLocalite(); |
| idLocation = idLocation.replaceAll("\"", ""); |
| idLocation = idLocation.replace('\\',' '); |
| idLocation = idLocation.trim(); |
| location=ent.getCommune(); |
| lieuDit=ent.getLieuDit(); |
| station=ent.getStation(); |
| if(idLocation.contains("000null") || idLocation.equals(null) || (idLocation.trim()).equals("")) { |
| idLocation="Inconnue" ; |
| } |
| if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) { |
| location="Inconnue" ; |
| } |
| if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
| lieuDit="Inconnue" ; |
| } |
| if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) { |
| station="Inconnue" ; |
| } |
| Node noeudMemeId = arbre.getNodeById(""+idLocation); |
| if(noeudMemeId == null) { |
| // on crée le noeud de l'identifiant location |
| noeudMemeId = creerNoeud(""+idLocation,idLocation); |
| root.appendChild(noeudMemeId) ; |
| } |
| // on teste si la localité existe |
| Node noeudMemeLoc = arbre.getNodeById(""+(idLocation+location)); |
| if(noeudMemeLoc == null) |
| { |
| // on crée le noeud de la location |
| noeudMemeLoc = creerNoeud(""+idLocation+location, location); |
| noeudMemeId.appendChild(noeudMemeLoc) ; |
| } |
| // on teste si le lieu dit existe |
| Node noeudMemeLieu = arbre.getNodeById(""+(idLocation+location+lieuDit)); |
| if(noeudMemeLieu == null) |
| { |
| // on crée le noeud du lieu dit |
| noeudMemeLieu = creerNoeud(idLocation+location+lieuDit, lieuDit); |
| noeudMemeLoc.appendChild(noeudMemeLieu) ; |
| } |
| // on teste si la station existe |
| Node noeudMemeStation = arbre.getNodeById(""+(idLocation+location+lieuDit+station)); |
| if(noeudMemeStation == null) { |
| // on crée le noeud de la station |
| noeudMemeStation = creerNoeud(idLocation+location+lieuDit+station,station); |
| noeudMemeLieu.appendChild(noeudMemeStation); |
| } |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,644 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.DateObservation; |
| import org.tela_botanica.client.modeles.ListeDateObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.GWT; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| 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 ArbreDateObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = 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 = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreDateObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreDateObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super("Dates"); |
| this.observationMediateur = obs; |
| arbreDonneesDates = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| this.addListener(new PanelListenerAdapter() { |
| // on instancie réellement les composants au moment du rendu pour |
| // accélérer l'affichage |
| // et éviter des bugs |
| public void onRender(Component component) { |
| // on interdit le drag and drop dans l'arbre |
| arbreDonneesDates.setEnableDD(false); |
| arbreDonneesDates.setId("x-view-tree-filter-date"); |
| arbreDonneesDates.setBorder(false); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.setRootVisible(true); |
| arbreDonneesDates.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreDonneesDates); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreDonneesDates.addListener(new TreePanelListenerAdapter() { |
| public void onClick(TreeNode node, EventObject e) { |
| nomFiltre = "" ; |
| donneesDateEnCours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(!arbreCharge) |
| { |
| /* arbreCharge = true ; |
| observationMediateur.obtenirDatesObservation() ;*/ |
| arbreDonneesDates.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| return ; |
| 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 ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = 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() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDateObservation) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText("Dates"); |
| String[] usObjRoot = { "Dates", "Dates", "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=(DateObservation) data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = renvoyerMois(Integer.parseInt(mois)) ; |
| jour= ent.getJour() ; |
| if(annee.contains("0000")) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00")) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = nouvelArbre.getNodeById(""+(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(""+(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(""+(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(""+(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(""+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(""+(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(""+(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() { |
| 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(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation ent = (Observation)nouvelleDonnees ; |
| String dateSpl[] = ent.getDate().split("/") ; |
| String annee= dateSpl[2]; |
| String mois= dateSpl[1]; |
| String jour= dateSpl[0]; |
| String moisLettre = renvoyerMois(Integer.parseInt(mois)) ; |
| Node root = arbreDonneesDates.getRootNode() ; |
| if(annee.contains("0000") || annee.equals(null)) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00") || jour.equals(null)) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(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(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| noeudMemeMois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| node_mois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(""+annee); |
| node_annee.setText(annee); |
| String[] usObj = {annee,annee,annee}; |
| node_annee.setUserObject(usObj); |
| root.appendChild(node_annee) ; |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| node_annee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| node_mois.appendChild(node_jour) ; |
| // TODO : améliorer la compararaison des noeuds |
| root.sort(comparerNoeuds()) ; |
| } |
| arbreDonneesDates.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 |
| */ |
| 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 |
| */ |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String valeursFiltrees[] = {nomFiltre, 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(""+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) |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| public String renvoyerMois(int numMois) { |
| switch (numMois) { |
| case 1: |
| return "janvier" ; |
| case 2: |
| return "fevrier" ; |
| case 3: |
| return "mars" ; |
| case 4: |
| return "avril" ; |
| case 5: |
| return "mai" ; |
| case 6: |
| return "juin" ; |
| case 7: |
| return "juillet" ; |
| case 8: |
| return "août" ; |
| case 9: |
| return "septembre" ; |
| case 10: |
| return "octobre" ; |
| case 11: |
| return "novembre" ; |
| case 12: |
| return "décembre" ; |
| default: |
| return "Inconnue" ; |
| } |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.clear(); |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,202 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant une image generique provenant d eflore |
| * |
| * @author David Delon |
| * |
| */ |
| public class ImageGeneriqueVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ImageGeneriqueVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public ImageGeneriqueVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| this.setCls("x-image-gen") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_taxon.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| observationMediateur.deMasquerChargementInfosObservations() ; |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/NuageMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,166 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| public class NuageMotsClesVue extends Window implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAChercher = "" ; |
| private int nbMotsClesMax = 1 ; |
| private boolean nuageCharge = false ; |
| public NuageMotsClesVue(ObservationMediateur om) { |
| super("Nuage de mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| setWidth(200); |
| this.setCloseAction(CLOSE); |
| //oMediateur.obtenirNuageMotsCles(this); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| if(!nuageCharge) { |
| masquerChargement(); |
| } |
| } |
| @Override |
| public void onRender(Component component) { |
| } |
| @Override |
| public void onShow(Component component) { |
| // TODO Auto-generated method stub |
| } |
| }); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| } |
| } |
| private void construireNuage() { |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| public void onBrowserEvent(Event e) { |
| //oMediateur.ajouterMotCleRecherche(e.getTarget().getInnerHTML()); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| this.clear(); |
| this.add(contenuHTML); |
| doLayout(); |
| nuageCharge = true; |
| demasquerChargement(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.unmask() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,603 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.ClickListener; |
| import com.google.gwt.user.client.ui.Image; |
| import com.google.gwt.user.client.ui.LoadListener; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.AnimationConfig; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.RegionPosition; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Panneau d'affichage d'une image avec des boutons précdents et suivant |
| * |
| * @author aurelien |
| * |
| */ |
| public class MiniZoomImageVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Le titre du panneau |
| */ |
| private static String titrePanneau = "Images liées"; |
| /** |
| * Panneau conteneur pour l'image |
| */ |
| private Panel imageConteneur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(""); |
| /** |
| * Bouton précédent |
| */ |
| private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Bouton suivant |
| */ |
| private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Taille originale Y de l'image |
| */ |
| private int imageHeight = 0; |
| /** |
| * Taille originale X de l'image |
| */ |
| private int imageWidth = 0; |
| /** |
| * Identifiant de l'image |
| */ |
| private String idImage = "0" ; |
| private String[] infosImages[] = null ; |
| private int index = 0 ; |
| /** |
| * true pour animer les transitions |
| */ |
| private boolean animerTransition = false; |
| /** |
| * Détermine la durée de la transition |
| */ |
| private float dureeAnimation = (float) 0.15; |
| /** |
| * Booleen d'initalisation général |
| */ |
| private boolean initialise = false; |
| /** |
| * Booleen d'initalisation du conteneur d'image |
| */ |
| private boolean conteneurInitialise = false; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| Image imgAgrandie = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MiniZoomImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public MiniZoomImageVue(ObservationMediateur im) { |
| super(titrePanneau); |
| setId("x-view-mini-zoom-panel"); |
| // on associe le médiateur |
| oMediateur = im; |
| prev.setStylePrimaryName("x-view-zoom-button-p"); |
| suiv.setStylePrimaryName("x-view-zoom-button-s"); |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors d'un déplacement de la roulette |
| if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) { |
| // on simule un clic sur le bouton précédent |
| if (event.getMouseWheelVelocityY() >= 1) { |
| prev.click(); |
| } |
| // ou suivant |
| if (event.getMouseWheelVelocityY() <= -1) { |
| suiv.click(); |
| } |
| } |
| if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) { |
| event.preventDefault() ; |
| int[] xy = {event.getClientX(),event.getClientY()} ; |
| afficherMenu(xy) ; |
| } |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| afficherPanneauAgrandi(); |
| } |
| } |
| }; |
| image.setPixelSize(150, 150); |
| infosImages = new String[0][0] ; |
| this.setHeader(true); |
| imageConteneur = new Panel() ; |
| imageConteneur.setBorder(false); |
| imageConteneur.add(image); |
| imageConteneur.setId("x-view-mini-zoom-img"); |
| // il n'existe pas de méthode pour ajouter un listener pour le double |
| // clic sur une image |
| // alors on lui dit manuellement de capter l'évènement double clic |
| image.sinkEvents(Event.ONDBLCLICK); |
| image.sinkEvents(Event.ONMOUSEWHEEL); |
| image.sinkEvents(Event.ONCONTEXTMENU) ; |
| // l'image de base est vide |
| image.setUrl(""); |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("15%"); |
| suiv.setWidth("15%"); |
| this.add(prev, new BorderLayoutData(RegionPosition.WEST)); |
| this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER)); |
| this.add(suiv, new BorderLayoutData(RegionPosition.EAST)); |
| imageConteneur.setMaskDisabled(true); |
| this.setBorder(false); |
| conteneurInitialise = true; |
| initialise = true; |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen qui dit si on doit répnadre l'évènement |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit une string |
| if (nouvelleDonnees instanceof String[][] && initialise |
| && conteneurInitialise && ((String[][])nouvelleDonnees).length != 0) { |
| infosImages = (String[][]) nouvelleDonnees; |
| index = 0 ; |
| afficherImage() ; |
| } else { |
| // sinon on met une image vide |
| infosImages = null ; |
| afficherImage(); |
| } |
| } |
| public void afficherImage() |
| { |
| // c'est l'url de l'image qu'on associe à la vue |
| if(infosImages != null && infosImages.length != 0) |
| { |
| setTitle(titrePanneau+" "+(index+1)+" / "+infosImages.length); |
| getImage().setUrl(convertirIdEnUrl(infosImages[index][0])); |
| imageWidth = Integer.parseInt(infosImages[index][1]); |
| imageHeight = Integer.parseInt(infosImages[index][2]); |
| verifierEtRetaillerImage(); |
| activerPanneau(true); |
| } else { |
| setTitle(titrePanneau); |
| getImage().setUrl("ill_liaison.png"); |
| imageWidth = getImage().getWidth(); |
| imageHeight = getImage().getHeight(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| activerPanneau(false); |
| } |
| if(infosImages != null && infosImages.length > 1) { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } else { |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau(boolean activer) { |
| if(activer) { |
| this.getEl().unmask(); |
| } else { |
| this.getEl().mask(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| // gestion du clic sur le bouton précedent |
| prev.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickListener(new ClickListener() { |
| // en cas de clic |
| public void onClick(Widget sender) { |
| if(infosImages.length != 0) { |
| if(index == infosImages.length - 1) |
| { |
| index = 0 ; |
| } |
| else |
| { |
| index++ ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Accesseur au conteneur de l'image |
| * |
| * @return le conteneur de l'image |
| */ |
| public Image getImage() { |
| return image; |
| } |
| /** |
| * Acesseurs pour l'identifiant de l'image |
| * @return l'id de l'image |
| */ |
| public String getIdImage() |
| { |
| return infosImages[index][0] ; |
| } |
| /** |
| * Accesseur pour le bouton précédent |
| * |
| * @return le bouton précédent |
| */ |
| public com.google.gwt.user.client.ui.Button getPrev() { |
| return prev; |
| } |
| /** |
| * Accesseur pour le bouton suivant |
| * |
| * @return le bouton suivant |
| */ |
| public com.google.gwt.user.client.ui.Button getSuiv() { |
| return suiv; |
| } |
| /** |
| * Setter pour la taille de l'image |
| * |
| * @param x |
| * la largeur en pixels |
| * @param y |
| * la hauteur en pixels |
| */ |
| public void setTailleImage(int x, int y) { |
| imageHeight = y; |
| imageWidth = x; |
| } |
| /** |
| * Setteur pour l'identifiant de l'image |
| * @param id le nouvel identifiant |
| */ |
| public void setIdImage(String id) |
| { |
| idImage = id ; |
| } |
| /** |
| * renvoie la taille originale de l'image |
| * |
| * @return un tableau de deux entiers contenant la largeur puis la hauteur |
| */ |
| public int[] getTailleImage() { |
| int[] taille = { imageHeight, imageWidth }; |
| return taille; |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| public void raz() { |
| infosImages = new String[0][0] ; |
| getImage().setUrl(""); |
| } |
| public void supprimerLiaisonImage() { |
| if(infosImages.length > 0) { |
| getImage().setUrl("") ; |
| int nouvelleTaille = infosImages.length - 1 ; |
| int indexSupp = index ; |
| String[][] nouveauInfosImages = new String[nouvelleTaille][3] ; |
| int j = 0 ; |
| for(int i = 0 ; i < infosImages.length ; i++) { |
| if(i != indexSupp) { |
| nouveauInfosImages[j] = infosImages[i] ; |
| j++ ; |
| } |
| } |
| infosImages = nouveauInfosImages ; |
| index = 0 ; |
| afficherImage() ; |
| } |
| } |
| public void afficherMenu(int[] xy) { |
| Menu mn = new Menu() ; |
| final Item suppLiaison = new Item("Supprimer la liaison") ; |
| mn.addItem(suppLiaison) ; |
| mn.addListener(new MenuListenerAdapter() { |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'aide |
| if (item.equals(suppLiaison)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| } |
| }) ; |
| mn.showAt(xy) ; |
| } |
| public String convertirIdEnUrl(String idImg) |
| { |
| int maxZeros = 9 - idImg.length(); |
| for (int j = 0; j < maxZeros; j++) { |
| idImg = "0" + idImg; |
| } |
| String baseUrl = Configuration.getImageBaseUrl() ; |
| String dossierNv1 = idImg.substring(0, 3); |
| String dossierNv2 = idImg.substring(3, 6); |
| String fichierNv = idImg.substring(6, 9); |
| String nomFichier = dossierNv1 + "_" + dossierNv2 + "_" + fichierNv; |
| String[] infosFichier = { nomFichier, dossierNv1, dossierNv2 }; |
| String urlImg = baseUrl + infosFichier[1] + "/" + infosFichier[2] + "/M/" |
| + infosFichier[0] + "_M.jpg"; |
| return urlImg ; |
| } |
| /** |
| * Verifie si l'image est plus grande que le conteneur et la retaille le cas |
| * echeant |
| */ |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| int[] dim = calculerDimensions(getTailleImage(),300,imageConteneur.getWidth()); |
| getImage().setSize("" + dim[0] + "px", |
| "" + dim[1] + "px"); |
| doLayout(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| } |
| public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {Math.round(XYresize[0]),Math.round(XYresize[1])} ; |
| return res; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = convertirIdEnUrl(infosImages[index][0]).replace("_M", "_L") ; |
| urlAgrandie = urlAgrandie.replace("/M/", "/L/") ; |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadListener(new LoadListener() { |
| public void onError(Widget sender) { |
| // TODO Auto-generated method stub |
| } |
| public void onLoad(Widget sender) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration((float) dureeAnimation); |
| imgElement.setHeight(tailleImage[1], a); |
| imgElement.setWidth(tailleImage[0], a); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], a); |
| winElement.setWidth(tailleImage[0], a); |
| } else { |
| imgElement.setHeight(tailleImage[1], false); |
| imgElement.setWidth(tailleImage[0], false); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], false); |
| winElement.setWidth(tailleImage[0], false); |
| } |
| } |
| }); |
| } else { |
| imgAgrandie.setUrl(urlAgrandie); |
| imgAgrandie.setVisible(true); |
| } |
| } |
| private void afficherPanneauAgrandi() { |
| agrandirImage(); |
| imgZoom.show(this.getElement()); |
| imgZoom.setPosition((int)(Window.getClientWidth() - Window.getClientWidth()*0.50),(int)(Window.getClientHeight() - Window.getClientHeight()*0.85)); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,203 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant la repartition d'une plante |
| * |
| * @author David Delon |
| * |
| */ |
| public class InformationRepartitionVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> Double cliquez pour agrandir l'image </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window("Agrandissement") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private InformationRepartitionVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public InformationRepartitionVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| image.sinkEvents(Event.ONDBLCLICK); |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| image.setUrl("ill_choro.png") ; |
| image.setPixelSize(150, 150); |
| } |
| else { |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max") ; |
| imgZoom.setHtml("<img src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| imgZoom.show(this.getElement()) ; |
| } |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,829 |
| package org.tela_botanica.client.vues.observation; |
| import java.util.Iterator; |
| import org.tela_botanica.client.modeles.ListeObservation; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.BarrePaginationVue; |
| import org.tela_botanica.client.interfaces.ListePaginable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.interfaces.VueListable; |
| 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.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.IntegerFieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| 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.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Tool; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.ToolbarButton; |
| import com.gwtext.client.widgets.ToolbarTextItem; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| 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.GridPanel; |
| import com.gwtext.client.widgets.grid.Renderer; |
| import com.gwtext.client.widgets.grid.event.GridListenerAdapter; |
| import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter; |
| /** |
| * Liste d'observation composée de ligne d'observation |
| * l'interface rafraichissable et l'interface vueListable |
| * |
| * @author David Delon 2008 |
| */ |
| public class ListeObservationVue extends GridPanel implements Rafraichissable, |
| VueListable, ListePaginable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig etatObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomSaisiObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig nomRetenuObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig lieuObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig dateObservation; |
| /** |
| * Config de colonne |
| */ |
| private ColumnConfig ordreObservation; |
| /** |
| * Modele de colonnes |
| */ |
| private ColumnModel modeleColonnes; |
| /** |
| * Store qui contient les données à afficher |
| */ |
| private Store st = null; |
| /** |
| * Barre de pagination |
| */ |
| private BarrePaginationVue bt = null ; |
| /** |
| * Numéro de page en cours |
| */ |
| private int pageEncours = 0 ; |
| /** |
| * Nombre de pages totales |
| */ |
| private int pageMax = 1 ; |
| /** |
| * Taille de page (par défaut 20) |
| */ |
| private int taillePage = 20 ; |
| /** |
| * Nombre d'éléments total correspondant à la requete |
| */ |
| private int nbElements = 0 ; |
| private ListeObservation cacheListeObservation = null; |
| private Tool exporterObservations = null ; |
| private final int KEY_ENTER = 13; |
| private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION"; |
| private boolean tailleInitialisee = false ; |
| /** |
| * Constructeur sans arguments (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ListeObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im le médiateur à associer |
| */ |
| public ListeObservationVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| setHeader(true); |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Observations"); |
| bt.setTaillePageParDefaut(20); |
| bt.setIntervallesPages(new String[] {"400","200", "100" , "50" , "20", "10"}) ; |
| Toolbar barreActions = new Toolbar(); |
| ToolbarButton publier = new ToolbarButton("Rendre publiques"); |
| publier.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(true); |
| } |
| }); |
| ToolbarButton privatiser = new ToolbarButton("Rendre privées"); |
| privatiser.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(false); |
| } |
| }); |
| ToolbarButton supprimer = new ToolbarButton("Supprimer"); |
| supprimer.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.supprimerObservations(); |
| } |
| }); |
| ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>"); |
| barreActions.addButton(publier); |
| barreActions.addButton(privatiser); |
| barreActions.addSpacer(); |
| barreActions.addButton(supprimer); |
| barreActions.addSpacer(); |
| barreActions.addItem(exporter); |
| this.setTopToolbar(barreActions) ; |
| this.setBottomToolbar(bt); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| this.setTitle("Observations") ; |
| // 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() { |
| 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 |
| { |
| } |
| return value.toString() ; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| 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() ; |
| } |
| } ; |
| etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() { |
| 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 "" ; |
| } |
| } |
| }); |
| nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200, true, colRend); |
| nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200, true, colRend); |
| lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200, true, colRend); |
| dateObservation = new ColumnConfig("Date", "date_observation", 120, true, dateRend); |
| ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50, true, colRend); |
| // on associe le modèle de colonnes |
| ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation}; |
| modeleColonnes = new ColumnModel(cm); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setEnableColumnResize(true); |
| //temp dd viewport desactive ajout de ces 2 lignes |
| // this.setAutoWidth(true); |
| // temp |
| // creation du store |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation"); |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| this.getView().setAutoFill(true); |
| this.getView().setForceFit(true) ; |
| // on crée un masque de chargement qui s'affichera lors des mises à jour |
| this.setLoadMask("Chargement"); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addGridRowListener(new GridRowListenerAdapter() { |
| // gestion du clic sur une ligne |
| public void onRowClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur et on lui passe le numéro de ligne |
| Record rd = getStore().getAt(rowIndex); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex,ordreObservation); |
| } |
| // gestion du clic droit |
| 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 |
| observationMediateur.montrerContextMenu(e); |
| } |
| // gestion du double clic |
| public void onRowDblClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur en lui passant le numéro de ligne |
| observationMediateur.doubleClicListeObservation(rowIndex); |
| } |
| }); |
| this.addGridListener(new GridListenerAdapter() { |
| public void onKeyPress(EventObject e) { |
| if(e.getKey() == KEY_ENTER) { |
| Record rd = getSelectionModel().getSelected(); |
| int rowIndex = st.indexOf(rd); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex, ordreObservation); |
| } |
| } |
| }); |
| this.addListener(new PanelListenerAdapter() { |
| public void onRender(Component c) { |
| ExtElement lienExport = Ext.get("lienExport") ; |
| lienExport.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations(); |
| } |
| }); |
| } |
| }); |
| } |
| /** |
| * Méthode héritée de l'interface VueListable |
| * Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
| */ |
| 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("ordre_observation"); |
| } |
| return id_selection; |
| } |
| /** |
| * Sélectionne des enregistrements donné |
| * @param sel un tableau d'enregistrement à selectionner |
| */ |
| public void selectionnerEnregistrements(Record[] sel) { |
| getSelectionModel().clearSelections(); |
| getSelectionModel().selectRecords(sel); |
| } |
| /** |
| * Accesseur pour la toolbar de pagination |
| * @return la toolbar de pagination |
| */ |
| public BarrePaginationVue getToolBarVue() |
| { |
| return bt ; |
| } |
| /** |
| * Recherche l'élement actuellement affiché et affiche son message de chargement |
| */ |
| public void masquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| masked.mask("Chargement") ; |
| } |
| } |
| /** |
| * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
| */ |
| public void demasquerChargement() |
| { |
| ExtElement masked = Ext.get(getId()) ; |
| if (masked!=null) { |
| if(masked.isMasked()) |
| { |
| masked.unmask() ; |
| } |
| } |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * @param nouvelleDonnees les nouvelles données |
| * @param repandreRafraichissement le booleen de notification du rafraichissement |
| */ |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) { |
| // si l'on a reçu une liste d'observation |
| if(nouvelleDonnees instanceof ListeObservation) |
| { |
| ListeObservation data = (ListeObservation) nouvelleDonnees ; |
| Object[][] observationData = new Object[data.size()][7]; |
| int i = 0 ; |
| if(data.size() == 0) |
| { |
| pageEncours = 0 ; |
| } |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| Observation obs=(Observation) data.get(it.next()); |
| observationData[i][0] = obs.getTransmis(); |
| observationData[i][1] = obs.getNomSaisi(); |
| observationData[i][2] = obs.getNomRetenu(); |
| observationData[i][3] = fabriquerLieu(obs); |
| observationData[i][4] = obs.getDate(); |
| observationData[i][5] = obs.getNumeroOrdre(); |
| observationData[i][6] = obs.getNumeroNomenclaturalSaisi(); |
| i++ ; |
| } |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation"); |
| // Non affiches : |
| FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation"); |
| // on associe le store |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(observationData); |
| final ArrayReader reader = new ArrayReader(rd); |
| final Store observationStore = new Store(dataProxy, reader); |
| st = observationStore ; |
| st.load() ; |
| // et on reconfigure et rafraichit la vue |
| this.reconfigure(st, this.getColumnModel()); |
| demasquerChargement(); |
| cacheListeObservation=data; |
| observationMediateur.onRafraichissementListeObservations(); |
| } |
| // 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,pages[0]) ; |
| masquerChargement(); |
| observationMediateur.obtenirListeObservation(this); |
| } |
| // si l'on a reçu une Observation |
| if(nouvelleDonnees instanceof Observation) { |
| Observation obs= (Observation) nouvelleDonnees; |
| if (obs.getNumeroOrdre()==null) { // Nouvelle observation |
| // On affiche la dernière page |
| pageEncours = pageMax ; |
| masquerChargement(); |
| observationMediateur.obtenirNombreObservation(); |
| } |
| else { // Modification d'une observation |
| masquerChargement(); |
| observationMediateur.obtenirNombreObservation(); |
| } |
| } |
| // Si on a effectué une suppression |
| if(nouvelleDonnees instanceof String) |
| { |
| String str = (String)nouvelleDonnees ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| } |
| // GESTION DE LA PAGINATION |
| public ListeObservation getCacheListeObservation() { |
| return cacheListeObservation; |
| } |
| /** |
| * 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()) ; |
| } |
| /** |
| * Appelle le modèle pour lui demander les données d'une page à afficher |
| * @param pageCourante le numéro de page à affciher |
| */ |
| public void changerNumeroPage(int pageCourante) { |
| pageEncours = pageCourante ; |
| masquerChargement(); |
| // On lance le chargerment des observations |
| observationMediateur.obtenirNombreObservation(); |
| getToolBarVue().changerPageCourante(pageCourante); |
| } |
| /** |
| * Appelle le modèle pour qu'il change la taille de page utilisée |
| * @param nouvelleTaillePage la nouvelle taille de page |
| */ |
| public void changerTaillePage(int nouvelleTaillePage) |
| { |
| taillePage = nouvelleTaillePage ; |
| pageEncours = calculerPageCourante(nbElements) ; |
| masquerChargement(); |
| // On lance le chargement des observations |
| observationMediateur.obtenirNombreObservation(); |
| // et on met à jour la taille de page dans les barres d'outils |
| getToolBarVue().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} ; |
| getToolBarVue().rafraichir(pages, false) ; |
| } |
| /** |
| * Renvoie la taille de page en cours d'utilisation |
| * @return la taille de page |
| */ |
| public int getTaillePage() { |
| return taillePage; |
| } |
| /** |
| * Renvoie le numéro de la page encours (attention on commence à 0) |
| * @return le numéro de la page en cours |
| */ |
| public int getPageEncours() { |
| return pageEncours; |
| } |
| public void afficherFiltres(String nLieu, String nDate, String nTaxon) |
| { |
| String titre = "Observations " ; |
| if(!nLieu.equals("")) |
| { |
| nLieu = nLieu.replaceAll(",", ", "); |
| titre += " - Lieu : "+nLieu ; |
| } |
| if(!nDate .equals("")) |
| { |
| nDate = nDate.replaceAll(",", ", "); |
| titre += " - Date : "+nDate ; |
| } |
| if(!nTaxon .equals("")) |
| { |
| titre += " - Recherche : "+nTaxon ; |
| } |
| this.setTitle(titre) ; |
| } |
| public void raz() { |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
| FieldDef defDateObservation = new StringFieldDef("date_observation"); |
| FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation"); |
| // Non affiches : |
| FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation"); |
| FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
| defLieuObservation, defDateObservation, defOrdreObservation }; |
| RecordDef rd = new RecordDef(defTab); |
| st = new Store(rd); |
| // on associe le store |
| this.setStore(st); |
| } |
| 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; |
| } |
| } |
| private String fabriquerLieu(Observation obs) { |
| String lieuModele = modeleLieu; |
| String commune = obs.getLocalite(); |
| String lieuDit = obs.getLieudit(); |
| String station = obs.getStation(); |
| String lieuCommuneFormate = ""; |
| String lieuDitFormate = ""; |
| String stationFormatee = ""; |
| if(commune != null && !commune.contains("000null") && !commune.trim().equals("")) { |
| String idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/"); |
| if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) { |
| idLoc = idLoc.replaceAll("%",""); |
| idLoc = idLoc.replaceAll("\"",""); |
| idLoc = idLoc.replace('\\',' '); |
| idLoc = idLoc.trim(); |
| lieuCommuneFormate += idLoc+" - "; |
| } |
| lieuCommuneFormate += commune; |
| lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE", lieuCommuneFormate); |
| } else { |
| lieuModele = lieuModele.replaceAll("IDLOCCOMMUNE,", lieuCommuneFormate); |
| } |
| if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) { |
| lieuDitFormate += lieuDit; |
| lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate); |
| } else { |
| lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate); |
| } |
| if(station != null && !station.contains("000null") && !station.trim().equals("")) { |
| stationFormatee += station; |
| lieuModele = lieuModele.replaceAll("STATION", stationFormatee); |
| } else { |
| lieuModele = lieuModele.replaceAll("STATION", stationFormatee); |
| } |
| lieuModele = lieuModele.trim(); |
| lieuModele = lieuModele.replaceAll(",$",""); |
| lieuModele = lieuModele.replaceAll(",^$",", "); |
| return lieuModele; |
| } |
| public boolean getTailleInitialisee() { |
| return tailleInitialisee ; |
| } |
| public void setTailleInitialisee() { |
| tailleInitialisee = true; |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java |
|---|
| New file |
| 0,0 → 1,182 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.ui.Label; |
| 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.event.KeyListener; |
| import com.gwtext.client.widgets.form.TextField; |
| public class MotsClesObsVue extends Panel implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| /** |
| * Barre de recherche |
| * |
| */ |
| private TextField champRecherche = null; |
| /** |
| * Booleen d'etat du filtre |
| */ |
| private boolean filtreModifie = false; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| /** |
| * bouton de validation |
| */ |
| private Button ok = null ; |
| private Button afficherNuage = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MotsClesObsVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec médiateur |
| * |
| * @param im |
| */ |
| public MotsClesObsVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| Label labelRecherche = new Label("Mots clés :"); |
| champRecherche = new TextField(); |
| ok = new Button("Rechercher"); |
| afficherNuage = new Button("Voir les mots clés"); |
| add(labelRecherche); |
| add(champRecherche); |
| add(ok); |
| add(afficherNuage); |
| setPaddings(5); |
| setBorder(false); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| private void ajouterListeners() { |
| // gestion de la touche entrée |
| champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() { |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| ok.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| afficherNuage.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| // oMediateur.afficherNuageMotsCles(); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String) { |
| champRecherche.setValue(champRecherche.getValueAsString()+" "+(String)nouvelleDonnees); |
| } |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| public String renvoyerNomFiltre() { |
| return "Recherche Mots clés"; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| public String[] renvoyerValeursAFiltrer() { |
| String[] valeurFiltre = new String[0]; |
| if(!motsAChercher.equals("")) { |
| valeurFiltre = new String[2]; |
| valeurFiltre[0] = "mots_cles"; |
| valeurFiltre[1] = motsAChercher; |
| } |
| return valeurFiltre; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Effectue quelque opérations dans la classe et envoie une requête de |
| * données au médiateur |
| */ |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| oMediateur.obtenirNombreObservation(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java |
|---|
| New file |
| 0,0 → 1,1573 |
| package org.tela_botanica.client.vues.observation; |
| // TODO Detecter redim et supprimer ajuster |
| import java.util.Date; |
| import java.util.Iterator; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.ListeObservation; |
| import org.tela_botanica.client.modeles.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.Observation; |
| import org.tela_botanica.client.modeles.ReferentielCommune; |
| import org.tela_botanica.client.modeles.ReferentielNom; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.maps.client.geom.LatLng; |
| import com.google.gwt.user.client.Window; |
| 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.ListenerConfig; |
| import com.gwtext.client.core.Position; |
| import com.gwtext.client.data.ArrayReader; |
| import com.gwtext.client.data.FieldDef; |
| import com.gwtext.client.data.MemoryProxy; |
| import com.gwtext.client.data.RecordDef; |
| import com.gwtext.client.data.SimpleStore; |
| import com.gwtext.client.data.Store; |
| import com.gwtext.client.data.StringFieldDef; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DatePicker; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.Toolbar; |
| import com.gwtext.client.widgets.Viewport; |
| import com.gwtext.client.widgets.event.BoxComponentListenerAdapter; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.DatePickerListener; |
| import com.gwtext.client.widgets.event.DatePickerListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.DateField; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.FormPanel; |
| import com.gwtext.client.widgets.form.MultiFieldPanel; |
| import com.gwtext.client.widgets.form.TextArea; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter; |
| import com.gwtext.client.widgets.layout.AnchorLayoutData; |
| import com.gwtext.client.widgets.layout.ColumnLayout; |
| import com.gwtext.client.widgets.layout.ColumnLayoutData; |
| import com.gwtext.client.widgets.layout.FormLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.data.Record; |
| /** |
| * 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 FormulaireSaisieObservationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| FormPanel panneauFormulaire = null; |
| private DateField date = null; |
| private TextField lieudit = null; |
| private TextField station = null; |
| private TextField milieu = null; |
| private TextField comment = null; |
| private ComboBox commune = null; |
| private String departement = null; |
| private ComboBox espece = null; |
| private String numeroNom = null; |
| private String numeroOrdre = null; |
| // Pour remise a zero partielle lors d'une validation |
| private enum Champs { |
| DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT ; |
| public String toString() { |
| switch(this) { |
| case DATE: |
| return "date"; |
| case COMMUNE: |
| return "commune"; |
| case LIEUDIT: |
| return "lieu dit"; |
| case STATION: |
| return "station"; |
| case MILIEU: |
| return "milieu"; |
| case COMMENT: |
| return "commentaire"; |
| case ESPECE: |
| return "espèce"; |
| case TOUT: |
| return "date, commune, lieu dit, station, milieu, espèce, commentaire"; |
| } |
| return TOUT.toString(); |
| } |
| }; |
| private String formatDate = null ; |
| private Button boutonOK = new Button("Créer"); |
| private Button boutonAnnuler = new Button("Réinitialiser"); |
| private boolean selectionCommune=false; |
| private boolean selectionEspece=false; |
| private boolean modification = false ; |
| private Toolbar bt = null ; |
| private final String VALEURS_MULTIPLES = "(Valeurs multiples)"; |
| private final String modeleMessageModif = "commune:lieu-dit:station:milieu:date:espece:commentaire"; |
| private boolean communeModifiee = false; |
| private boolean lieuDitModifie = false; |
| private boolean stationModifiee = false; |
| private boolean milieuModifie = false; |
| private boolean dateModifiee = false; |
| private boolean especeModifiee = false; |
| private boolean commModifie = false; |
| private final int KEY_ALT = 18; |
| private final int KEY_BACKSPACE = 8; |
| private final int KEY_CTRL = 17; |
| private final int KEY_DELETE = 46; |
| private final int KEY_DOWN = 40; |
| private final int KEY_END = 35; |
| private final int KEY_ENTER = 13; |
| private final int KEY_ESCAPE = 27; |
| private final int KEY_HOME = 36; |
| private final int KEY_LEFT = 37; |
| private final int KEY_PAGEDOWN = 34; |
| private final int KEY_PAGEUP = 33; |
| private final int KEY_RIGHT = 39; |
| private final int KEY_SHIFT = 16; |
| private final int KEY_TAB = 9; |
| private final int KEY_UP = 38; |
| /** |
| * Combobox permettant de selectionner le mode |
| * modification ou bien création |
| */ |
| private ComboBox selecteurMode = new ComboBox(); |
| Store storeMode = null ; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false ; |
| private Panel panneauIntermediaire; |
| private Panel panneauPremierColonne; |
| private Panel panneauSecondeColonne; |
| private boolean masseModification =false ; |
| private TextField longitude; |
| private TextField latitude; |
| private MultiFieldPanel coordPanel; |
| private TextField coordonnees; |
| private HTML accesformulaire; |
| private HTML basculerverscarto; |
| private boolean longlatAjoutee; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private FormulaireSaisieObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im |
| */ |
| public FormulaireSaisieObservationVue(ObservationMediateur obs) |
| { |
| super("Saisie"); |
| // on associe le médiateur |
| observationMediateur = obs ; |
| panneauFormulaire = new FormPanel(Position.RIGHT); |
| panneauFormulaire.setBorder(false); |
| // Panneau intermediaire qui contient deux colonnes de formulaire |
| panneauIntermediaire = new Panel(); |
| if (Window.getClientWidth()> Window.getClientHeight()) { |
| panneauIntermediaire.setLayout(new ColumnLayout()); |
| } |
| else { |
| panneauIntermediaire.setLayout(new RowLayout()); |
| } |
| panneauIntermediaire.setBorder(false); |
| if (Ext.isIE6()) { |
| panneauIntermediaire.setWidth(800); |
| } |
| //create first panel and add fields to it |
| panneauPremierColonne = new Panel(); |
| panneauPremierColonne.setLayout(new FormLayout()); |
| panneauPremierColonne.setBorder(false); |
| //create second panel and add fields to it |
| panneauSecondeColonne = new Panel(); |
| panneauSecondeColonne.setLayout(new FormLayout()); |
| panneauSecondeColonne.setBorder(false); |
| this.setPaddings(5) ; |
| // Accesskey pour debugging |
| commune=new ComboBox("Commune","commune\" accesskey=\"1"); |
| final String resultTplCommune = "<div class=\"search-item-commune\">{commune}</div>"; |
| commune.setTpl(resultTplCommune); |
| commune.setMode(ComboBox.REMOTE); |
| // commune.setPageSize(10); // Ne fonctionne pas |
| commune.setItemSelector("div.search-item-commune"); |
| commune.setTypeAhead(true); |
| commune.setLoadingText("Recherche..."); |
| commune.setHideTrigger(true); |
| //commune.setTabIndex(1); |
| panneauPremierColonne.add(commune, new AnchorLayoutData("95%")); |
| station = new TextField("Station", "station"); |
| station.setAllowBlank(true); |
| //station.setTabIndex(3); |
| panneauPremierColonne.add(station, new AnchorLayoutData("95%")); |
| longitude = new TextField("X", "x", 100); |
| longitude.setAllowBlank(true); |
| latitude = new TextField("Y", "y", 100); |
| latitude.setAllowBlank(true); |
| // Panneau de type plusieurs champs de formulaire sur une meme ligne, où seront renseignés X/Y |
| coordPanel = new MultiFieldPanel(); |
| coordPanel.setVisible(false); |
| coordPanel.addToRow(longitude, new ColumnLayoutData(0.5)); |
| coordPanel.addToRow(latitude, new ColumnLayoutData(0.5)); |
| coordPanel.setBorder(false); |
| //création du champs coordonnées |
| coordonnees = new TextField("Coordonnées", "", 0); |
| coordonnees.setMaxLength(0); |
| coordonnees.setReadOnly(true); |
| coordonnees.setCls("fieldname"); |
| //création du lien "saisie X/Y" dans le formulaire |
| accesformulaire = new HTML("<a id=\"lien_coord\" href=\"#\" tabindex=\"7\">Saisie X/Y</a>"); |
| accesformulaire.addStyleName("lien"); |
| //création info bulle sur le lien "saisie X/Y" |
| ToolTip tip1 = new ToolTip(); |
| tip1.setHtml("X / Y sont les longitudes / latitudes, à remplir en degrés décimaux"); |
| tip1.applyTo(accesformulaire.getElement()); |
| //ajout d'un listener sur le lien "saisie X/Y" |
| coordPanel.addListener(new PanelListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| ExtElement lienCoord = Ext.get("lien_coord"); |
| lienCoord.removeAllListeners(); |
| lienCoord.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| coordPanel.setVisible(!coordPanel.isVisible()); |
| } |
| }) ; |
| ExtElement lienCarto = Ext.get("lien_carto"); |
| lienCarto.removeAllListeners(); |
| lienCarto.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| if(coordonneesValides() == null) { |
| if(commune.getValue() != null && !commune.getValue().equals("")) { |
| obtenirInformationCommune(); |
| longlatAjoutee = true; |
| } else { |
| Window.alert("Veuillez renseigner au moins une commune ou des coordonnées pour la géolocalisation"); |
| } |
| } else { |
| obtenirInformationCoord(); |
| } |
| } |
| }); |
| } |
| }); |
| //création du lien "Accès carto" dans le formulaire |
| basculerverscarto = new HTML(" <a id=\"lien_carto\" href=\"#\" tabindex=\"6\">Selection depuis la carto</a>"); |
| basculerverscarto.addStyleName("lien"); |
| //création info bulle sur le lien "accès carto" |
| ToolTip tip2 = new ToolTip(); |
| tip2.setHtml("Via une carte, obtenez les coordonnées (longitude/latitude) de votre observation "); |
| tip2.applyTo(basculerverscarto.getElement()); |
| //Sur une meme ligne, ajout de plusieurs champs |
| final MultiFieldPanel htmlPanel = new MultiFieldPanel(); |
| htmlPanel.addToRow(coordonnees, 100); |
| htmlPanel.addToRow(basculerverscarto, new ColumnLayoutData(0.5)); |
| htmlPanel.addToRow(accesformulaire, new ColumnLayoutData(0.5)); |
| htmlPanel.setBorder(false); |
| htmlPanel.setId("x-coord-panel"); |
| panneauPremierColonne.add(htmlPanel); |
| panneauPremierColonne.add(coordPanel); |
| date = new DateField("Date", "date", 100); |
| date.setAllowBlank(true); |
| formatDate = "d/m/Y"; |
| date.setFormat(formatDate) ; |
| //date.setTabIndex(5); |
| panneauPremierColonne.add(date, new AnchorLayoutData("60%")); |
| espece=new ComboBox("Espèce","nom"); |
| final String resultTplEspece = "<div class=\"search-item-espece\">{nom}</div>"; |
| espece.setTpl(resultTplEspece); |
| espece.setMode(ComboBox.REMOTE); |
| // commune.setPageSize(10); // Ne fonctionne pas |
| espece.setItemSelector("div.search-item-espece"); |
| espece.setTypeAhead(true); |
| espece.setLoadingText("Recherche..."); |
| espece.setHideTrigger(true); |
| //espece.setTabIndex(6); |
| panneauPremierColonne.add(espece, new AnchorLayoutData("95%")); |
| lieudit = new TextField("Lieu-dit", "lieudit"); |
| lieudit.setAllowBlank(true); |
| //lieudit.setTabIndex(2); |
| panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%")); |
| milieu = new TextField("Milieu", "milieu"); |
| milieu.setAllowBlank(true); |
| //milieu.setTabIndex(4); |
| panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%")); |
| comment = new TextArea("Notes", "comment"); |
| comment.setAllowBlank(true); |
| comment.setHeight(50); |
| //comment.setTabIndex(7); |
| panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") ); |
| if (Window.getClientWidth()> Window.getClientHeight()) { |
| panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5)); |
| panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5)); |
| } |
| else { |
| panneauIntermediaire.add(panneauPremierColonne); |
| panneauIntermediaire.add(panneauSecondeColonne); |
| } |
| panneauFormulaire.add(panneauIntermediaire); |
| Object[][] mode = {{"création",false} , {"modification", 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("création") ; |
| selecteurMode.setEditable(false) ; |
| selecteurMode.setCls("x-selec-crea") ; |
| bt = new Toolbar() ; |
| bt.addSpacer() ; |
| bt.addText("Mode de saisie ") ; |
| bt.addField(selecteurMode) ; |
| boutonOK.setTabIndex(8); |
| boutonAnnuler.setTabIndex(9); |
| if (Ext.isIE6()) { |
| panneauPremierColonne.setButtonAlign(Position.RIGHT); |
| panneauPremierColonne.addButton(boutonOK); |
| panneauSecondeColonne.setButtonAlign(Position.LEFT); |
| panneauSecondeColonne.addButton(boutonAnnuler); |
| } |
| else { |
| panneauFormulaire.addButton(boutonOK); |
| panneauFormulaire.addButton(boutonAnnuler); |
| } |
| selecteurMode.addListener(new ComboBoxListenerAdapter() { |
| 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")) ; |
| } |
| }); |
| this.add(panneauFormulaire) ; |
| this.setTopToolbar(bt) ; |
| this.setAutoScroll(true); |
| panneauFormulaire.addListener(new PanelListenerAdapter() { |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) { |
| panneauIntermediaire.setWidth(rawWidth); |
| panneauIntermediaire.setHeight(rawHeight); |
| }}); |
| // on ajoute les listeners |
| ajouterListeners() ; |
| saisieTabindex(); |
| } |
| private void ajouterListeners() |
| { |
| // Listener completion communne |
| commune.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| commune.setValue(record.getAsString("commune")); |
| departement=record.getAsString("departement"); |
| selectionCommune=true; |
| } |
| }); |
| ListenerConfig listenerConfigCommune=new ListenerConfig(); |
| listenerConfigCommune.setDelay(10); |
| listenerConfigCommune.setStopPropagation(false); |
| listenerConfigCommune.setStopEvent(false); |
| commune.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| if (selectionCommune) { |
| communeModifiee= true; |
| selectionCommune=false; |
| } |
| else { |
| validerSaisie(Champs.COMMUNE); |
| // lancer mise a jour |
| } |
| break; |
| default: |
| departement=""; |
| obtenirListeReferentielCommune(); |
| communeModifiee= true; |
| break; |
| } |
| } |
| }, listenerConfigCommune |
| ); |
| date.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| if(date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| date.clearInvalid(); |
| } |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.DATE); |
| break; |
| default: |
| dateModifiee = true; |
| } |
| } |
| }); |
| date.addListener(new DatePickerListenerAdapter() { |
| public void onSelect(DatePicker dataPicker, Date date) { |
| dateModifiee = true; |
| } |
| }); |
| station.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.STATION); |
| break; |
| default: |
| stationModifiee = true; |
| } |
| } |
| }); |
| // Listener completion espece |
| espece.addListener(new ComboBoxListenerAdapter() { |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| espece.setValue(record.getAsString("nom")); |
| numeroNom=record.getAsString("numeroNom"); |
| selectionEspece=true; |
| observationMediateur.obtenirImageInformationExternes(numeroNom); |
| } |
| }); |
| ListenerConfig listenerConfigEspece=new ListenerConfig(); |
| listenerConfigEspece.setDelay(10); |
| listenerConfigEspece.setStopPropagation(false); |
| listenerConfigEspece.setStopEvent(false); |
| espece.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| if(selectionEspece) { |
| especeModifiee = true; |
| selectionEspece=false; |
| } |
| else { |
| validerSaisie(Champs.ESPECE); |
| } |
| break; |
| default: |
| numeroNom=""; |
| obtenirListeReferentielNom(); |
| especeModifiee = true; |
| break; |
| } |
| } |
| }, listenerConfigEspece |
| ); |
| lieudit.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.LIEUDIT); |
| break; |
| default: |
| lieuDitModifie = true; |
| } |
| } |
| }); |
| milieu.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| // TODO Auto-generated method stub |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| validerSaisie(Champs.MILIEU); |
| break; |
| default: |
| milieuModifie = true; |
| } |
| } |
| }); |
| comment.addKeyPressListener(new EventCallback() { |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| default: |
| commModifie = true; |
| } |
| } |
| }); |
| boutonOK.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(modification) { |
| if(masseModification) { |
| modifierObservationEnMasse(null); |
| } else { |
| modifierObservation() ; |
| } |
| } |
| else { |
| ajouterObservation(); |
| } |
| } |
| }); |
| boutonAnnuler.addListener(new ButtonListenerAdapter() { |
| public void onClick(Button button, EventObject e) { |
| if(modification) |
| { |
| supprimerObservation() ; |
| } |
| else |
| { |
| raz(); |
| } |
| } |
| }); |
| this.addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container self) { |
| commune.focus(); |
| } |
| }); |
| } |
| /** |
| * Validation de la saisie |
| */ |
| private void validerSaisie(Champs champs) { |
| if(modification) { |
| if(masseModification) { |
| modifierObservationEnMasse(champs); |
| } else { |
| modifierObservation(); |
| } |
| raz(champs); |
| } |
| else { |
| ajouterObservation(); |
| raz(champs); |
| } |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() |
| { |
| this.setDisabled(true) ; |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() |
| { |
| this.setDisabled(false) ; |
| } |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| // si l'on a reçu une liste du referentiel commune (completion referentiel commune) |
| if(nouvelleDonnees instanceof ListeReferentielCommune) |
| { |
| ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ; |
| Object[][] communeData = new Object[data.size()][2]; |
| int i = 0 ; |
| // on la parse et on récupère les informations quiç nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| ReferentielCommune ref=(ReferentielCommune) data.get(it.next()); |
| communeData[i][0]= ref.getCommune(); |
| communeData[i][1]= ref.getDepartement(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defCommune = new StringFieldDef("commune"); |
| FieldDef defDepartement = new StringFieldDef("departement"); |
| FieldDef[] defTab = { defCommune, defDepartement}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(communeData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| store.load() ; |
| commune.setStore(store); |
| commune.expand(); |
| } |
| // si l'on a reçu une liste du référentiel nom (complétion referentiel nom) |
| if(nouvelleDonnees instanceof ListeReferentielNom) |
| { |
| ListeReferentielNom data = (ListeReferentielNom) nouvelleDonnees ; |
| Object[][] nomData = new Object[data.size()][2]; |
| int i = 0 ; |
| // on la parse et on récupère les informations quiç nous interessent |
| for (Iterator it = data.keySet().iterator(); it.hasNext();) |
| { |
| ReferentielNom ref=(ReferentielNom) data.get(it.next()); |
| nomData[i][0]= ref.getNom(); |
| nomData[i][1]= ref.getNumeroNom(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defNom = new StringFieldDef("nom"); |
| FieldDef defNumeroNom = new StringFieldDef("numeroNom"); |
| FieldDef[] defTab = { defNom, defNumeroNom}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(nomData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| store.load() ; |
| espece.setStore(store); |
| } |
| // On recoit une observation dont on veut afficher le detail |
| if(nouvelleDonnees instanceof Observation) |
| { |
| Observation obs = (Observation)nouvelleDonnees ; |
| afficherDetailsObservation(obs) ; |
| } |
| if(nouvelleDonnees instanceof ListeObservation) { |
| ListeObservation listeObs = (ListeObservation)nouvelleDonnees; |
| calculerAfficherDifferences(listeObs); |
| } |
| // Sur Mise à jour ou suppression d'une suppression ? |
| if(nouvelleDonnees instanceof String) |
| { |
| String str = (String)nouvelleDonnees ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| if(nouvelleDonnees instanceof String[]) { |
| String[] anumNom = (String[])nouvelleDonnees ; |
| numeroNom = anumNom[1]; |
| espece.setValue(anumNom[0]); |
| setModification("false"); |
| } |
| if(nouvelleDonnees instanceof EntiteGeographiqueObservation) |
| { |
| EntiteGeographiqueObservation infosComm = (EntiteGeographiqueObservation)nouvelleDonnees ; |
| rafraichirCommuneEtCoord(infosComm); |
| } |
| } |
| private void rafraichirCommuneEtCoord(EntiteGeographiqueObservation infosCom) { |
| String nCommune = ""; |
| if(infosCom.getLocation() != null && !infosCom.getLocation().equals("")) { |
| nCommune += infosCom.getLocation(); |
| } |
| if(infosCom.getIdLocation() != null && !infosCom.getIdLocation().equals("")) { |
| nCommune += " ("+infosCom.getIdLocation()+")"; |
| departement = infosCom.getIdLocation(); |
| } |
| commune.setValue(nCommune); |
| if(infosCom.getLat() != null && !infosCom.getLat().equals("")) { |
| latitude.setValue(infosCom.getLat()); |
| } |
| if(infosCom.getLon() != null && !infosCom.getLon().equals("")) { |
| longitude.setValue(infosCom.getLon()); |
| } |
| } |
| public void obtenirListeReferentielCommune() { |
| String com=commune.getText()/*.replaceAll(" ","/")*/; |
| com=com.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielCommune(this,com); |
| } |
| public void obtenirListeReferentielNom() { |
| String esp=espece.getText().replaceAll(" ","/*"); |
| esp=esp.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielNom(this,esp); |
| } |
| public void ajouterObservation() { |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue()); |
| observationMediateur.ajouterObservation(obs); |
| } |
| private void modifierObservation() { |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),date.getRawValue()); |
| obs.setNumeroOrdre(numeroOrdre); |
| observationMediateur.modifierObservation(obs); |
| selecteurMode.setValue("création"); |
| setModification("false"); |
| } |
| private void modifierObservationEnMasse(Champs champModifie) { |
| String communeM = null; |
| String departementM = null; |
| String numNomSelM = null; |
| String lieuDitM = null; |
| String stationM = null; |
| String milieuM = null; |
| String dateM = null; |
| String especeM = null; |
| String commM = null; |
| String champs = modeleMessageModif; |
| if(communeModifiee) { |
| communeM = commune.getText(); |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| departementM = departement; |
| } else { |
| champs = champs.replaceAll("commune", ""); |
| } |
| if(lieuDitModifie) { |
| lieuDitM = lieudit.getText(); |
| }else { |
| champs = champs.replaceAll(":lieu-dit", ""); |
| } |
| if(stationModifiee) { |
| stationM = station.getText(); |
| }else { |
| champs = champs.replaceAll(":station", ""); |
| } |
| if(milieuModifie) { |
| milieuM = milieu.getText(); |
| }else { |
| champs = champs.replaceAll(":milieu", ""); |
| } |
| if(dateModifiee && !date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| dateM = date.getRawValue(); |
| }else { |
| champs = champs.replaceAll(":date", ""); |
| } |
| if(especeModifiee) { |
| especeM = espece.getText(); |
| numNomSelM = numeroNom; |
| }else { |
| champs = champs.replaceAll(":espece", ""); |
| } |
| if(commModifie) { |
| commM = comment.getText(); |
| }else { |
| champs = champs.replaceAll(":commentaire", ""); |
| } |
| champs = champs.replaceAll(":",", "); |
| if(champs.startsWith(",")) { |
| champs = champs.replaceFirst(",", ""); |
| } |
| String message = "Voulez vous modifier le(s) champ(s) suivant(s) : "+champs+" pour les observations selectionnées ?" ; |
| if(champs.trim().equals("")) { |
| Window.alert("Aucun champ n'a été modifié"); |
| } else { |
| Observation obs = new Observation(especeM,numNomSelM,communeM,departementM,lieuDitM,stationM,milieuM, commM,dateM); |
| obs.setNumeroOrdre(numeroOrdre); |
| if(Window.confirm(message)) { |
| observationMediateur.modifierObservationEnMasse(obs); |
| reinitialiserValeurModifiees(); |
| } |
| } |
| } |
| private void supprimerObservation() { |
| observationMediateur.supprimerObservation(this, numeroOrdre); |
| } |
| public void afficherDetailsObservation(Observation obs) |
| { |
| raz() ; |
| String idLoc ; |
| if(obs.getIdentifiantLocalite() != VALEURS_MULTIPLES) { |
| idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/"); |
| idLoc = idLoc.replaceAll("%",""); |
| idLoc = idLoc.replaceAll("\"",""); |
| idLoc = idLoc.replace('\\',' '); |
| idLoc = idLoc.trim(); |
| } else { |
| idLoc = obs.getIdentifiantLocalite(); |
| } |
| if(!obs.getDate().equals("null") && !obs.getDate().equals("000null") && !obs.getDate().equals(VALEURS_MULTIPLES)) { |
| String[] dateEtHeure = obs.getDate().split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| date.setValue(dateEtHeure[0]) ; |
| } |
| else |
| { |
| date.setRawValue(""); |
| } |
| } else { |
| date.setRawValue(VALEURS_MULTIPLES); |
| date.clearInvalid(); |
| } |
| if(!obs.getLieudit().equals("null") && !obs.getLieudit().equals("000null")) { |
| lieudit.setValue(obs.getLieudit()) ; |
| } |
| if(!obs.getStation().equals("null") && !obs.getStation().equals("000null")) { |
| station.setValue(obs.getStation()) ; |
| } |
| if(!obs.getMilieu().equals("null") && !obs.getMilieu().equals("000null")) { |
| milieu.setValue(obs.getMilieu()) ; |
| } |
| if(!obs.getCommentaire().equals("null") && !obs.getCommentaire().equals("000null")) { |
| comment.setValue(obs.getCommentaire()) ; |
| } |
| if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) { |
| if(!idLoc.equals("000null")) { |
| if(!idLoc.equals(VALEURS_MULTIPLES)) { |
| commune.setValue(obs.getLocalite()+" ("+idLoc+")") ; |
| } else { |
| commune.setValue(VALEURS_MULTIPLES); |
| } |
| } |
| else |
| { |
| commune.setValue(obs.getLocalite()); |
| } |
| } |
| if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) { |
| departement = idLoc; |
| } |
| if(!obs.getNomSaisi().equals("null") && !obs.getNomSaisi().equals("000null")) { |
| espece.setValue(obs.getNomSaisi()) ; |
| } |
| if(!obs.getNumeroNomenclaturalSaisi().equals("null") && !obs.getNumeroNomenclaturalSaisi().equals("000null")) { |
| numeroNom = obs.getNumeroNomenclaturalSaisi() ; |
| } |
| if(!obs.getNumeroOrdre().equals("null") && !obs.getNumeroOrdre().equals("000nu2ll")) { |
| numeroOrdre = obs.getNumeroOrdre() ; |
| } |
| } |
| public void raz() |
| { |
| raz(Champs.TOUT); |
| } |
| public void raz(Champs champs) |
| { |
| switch (champs) { |
| case DATE: |
| date.reset() ; |
| break; |
| case LIEUDIT: |
| lieudit.reset() ; |
| break; |
| case STATION: |
| station.reset() ; |
| break; |
| case MILIEU: |
| milieu.reset() ; |
| break; |
| case COMMENT: |
| comment.reset() ; |
| break; |
| case COMMUNE: |
| commune.reset() ; |
| departement =""; |
| break; |
| case ESPECE: |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| case TOUT: |
| commune.reset(); |
| date.reset() ; |
| lieudit.reset() ; |
| station.reset() ; |
| milieu.reset() ; |
| comment.reset() ; |
| milieu.reset() ; |
| latitude.reset(); |
| longitude.reset(); |
| departement =""; |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| } |
| } |
| private void setModification(String mode) |
| { |
| if(mode.equals("true")) { |
| boutonOK.setText("Modifier") ; |
| setTitle("Modification") ; |
| boutonAnnuler.setText("Supprimer") ; |
| modification = true ; |
| selecteurMode.removeClass("x-selec-crea") ; |
| selecteurMode.setCls("x-selec-modif") ; |
| observationMediateur.onModeModification(); |
| } |
| else |
| { |
| boutonOK.setText("Ajouter") ; |
| setTitle("Saisir") ; |
| boutonAnnuler.setText("Réinitialiser") ; |
| modification = false ; |
| selecteurMode.removeClass("x-selec-modif") ; |
| selecteurMode.setCls("x-selec-crea") ; |
| observationMediateur.onModeCreation(); |
| } |
| } |
| /** |
| * renvoie vrai si on est en mode modification, faux si on est en mode création |
| * @return |
| */ |
| public boolean getModification() |
| { |
| return modification ; |
| } |
| /** |
| * renvoie vrai si on est en mode modification de masse, faux sinon |
| * @return |
| */ |
| public boolean getMasseModification() |
| { |
| return masseModification ; |
| } |
| 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; |
| } |
| } |
| public void setMasseModification(boolean masseModification) { |
| this.masseModification = masseModification; |
| if(masseModification) { |
| reinitialiserValeurModifiees(); |
| } |
| } |
| private void calculerAfficherDifferences(ListeObservation listeObs) { |
| String departement = null; |
| String commune = null; |
| String lieuDit = null; |
| String station = null; |
| String milieu = null; |
| String espece = null; |
| String date = null; |
| String notes = null; |
| String ordreObs = ""; |
| for(Iterator<String> it = listeObs.keySet().iterator();it.hasNext();) { |
| Observation obsEnCours = listeObs.get(it.next()); |
| departement = comparerDifferencesChamps(departement, obsEnCours.getIdentifiantLocalite()); |
| commune = comparerDifferencesChamps(commune, obsEnCours.getLocalite()); |
| lieuDit = comparerDifferencesChamps(lieuDit, obsEnCours.getLieudit()); |
| station = comparerDifferencesChamps(station, obsEnCours.getStation()); |
| milieu = comparerDifferencesChamps(milieu, obsEnCours.getMilieu()); |
| espece = comparerDifferencesChamps(espece, obsEnCours.getNomSaisi()); |
| date = comparerDifferencesChamps(date, obsEnCours.getDate()); |
| notes = comparerDifferencesChamps(notes, obsEnCours.getCommentaire()); |
| ordreObs += obsEnCours.getNumeroOrdre()+","; |
| } |
| Observation obs=new Observation(espece,numeroNom,commune,departement,lieuDit,station,milieu, notes,date); |
| obs.setNumeroOrdre(ordreObs); |
| rafraichir(obs, false); |
| } |
| private String comparerDifferencesChamps(String valeurActuelle, String nouvelleValeur) { |
| String retour = "000null"; |
| if(valeurActuelle == null) { |
| retour = nouvelleValeur; |
| } else { |
| if(valeurActuelle.equals(nouvelleValeur)) { |
| retour = valeurActuelle; |
| } else { |
| retour = VALEURS_MULTIPLES; |
| } |
| } |
| return retour; |
| } |
| private void reinitialiserValeurModifiees() { |
| communeModifiee = false; |
| lieuDitModifie = false; |
| stationModifiee = false; |
| milieuModifie = false; |
| dateModifiee = false; |
| especeModifiee = false; |
| commModifie = false; |
| } |
| public void saisieTabindex() |
| { |
| selecteurMode.setTabIndex(0); |
| commune.setTabIndex(1); |
| lieudit.setTabIndex(2); |
| station.setTabIndex(3); |
| milieu.setTabIndex(4); |
| coordonnees.setTabIndex(-1); |
| coordonnees.addListener(new TextFieldListenerAdapter() { |
| public void onFocus(Field field) { |
| if(coordPanel.isVisible()) { |
| longitude.focus(); |
| } else { |
| Ext.get("lien_carto").focus(); |
| } |
| } |
| }); |
| longitude.setTabIndex(8); |
| latitude.setTabIndex(9); |
| comment.setTabIndex(10); |
| date.setTabIndex(11); |
| espece.setTabIndex(12); |
| boutonOK.setTabIndex(13); |
| boutonAnnuler.setTabIndex(14); |
| } |
| private void obtenirInformationCoord() { |
| if(coordonneesValides() != null) { |
| observationMediateur.obtenirInformationCoord(LatLng.newInstance(coordonneesValides()[0],coordonneesValides()[1])); |
| } else { |
| Window.alert("Les coordonnées saisies sont invalides"); |
| } |
| } |
| private void obtenirInformationCommune() { |
| observationMediateur.obtenirInformationCommune(commune.getValue(), obtenirDepartementAPartirChampCommune()); |
| } |
| private double[] coordonneesValides() { |
| try { |
| double lat = Double.parseDouble(latitude.getValueAsString().replaceAll(",", ".")); |
| double lon = Double.parseDouble(longitude.getValueAsString().replaceAll(",", ".")); |
| double[] coord = {lat, lon}; |
| return coord; |
| } catch (NumberFormatException ne) { |
| return null; |
| } |
| } |
| private String obtenirDepartementAPartirChampCommune() { |
| if(departement.equals("000null") || departement.equals("")) { |
| String[] depCom = commune.getText().split(" "); |
| if(depCom.length > 1) { |
| String dep = depCom[1].replace('(', ' '); |
| dep =dep.replace(')', ' '); |
| dep = dep.trim(); |
| dep = dep.replace('\\',' '); |
| dep = dep.trim(); |
| try |
| { |
| int nDep = Integer.parseInt(dep); |
| if(nDep > 0 && nDep < 110) { |
| departement = dep ; |
| } |
| } |
| catch(NumberFormatException e) |
| { |
| departement = "" ; |
| } |
| } |
| } |
| return departement; |
| } |
| private Field obtenirCorrespondanceChampsEnum(Champs champ) { |
| switch(champ) { |
| case DATE: |
| return date; |
| case COMMUNE: |
| return commune; |
| case LIEUDIT: |
| return lieudit; |
| case STATION: |
| return station; |
| case MILIEU: |
| return milieu; |
| case COMMENT: |
| return comment; |
| case ESPECE: |
| return espece; |
| } |
| return null; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java |
|---|
| New file |
| 0,0 → 1,146 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.ArbreMotsClesFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreEntiteGeographiqueObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.RechercheLibreVue; |
| import com.gwtext.client.widgets.Panel; |
| 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 PanneauFiltresObservationVues extends Panel { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * L'arbre pour la recherche entite geographique |
| * |
| */ |
| private ArbreEntiteGeographiqueObservationFiltreVue arbreEntiteGeographiqueObservationFiltreVue = null; |
| /** |
| * L'arbre pour la recherche date |
| * |
| */ |
| private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null; |
| private ArbreMotsClesFiltreVue arbreMotsClesFiltreVue = null ; |
| private RechercheLibreVue rechercheLibreVue = null; |
| /** |
| * Construcuteur sans argument (privé car on ne doit pas l'utiliser) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauFiltresObservationVues() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public PanneauFiltresObservationVues(ObservationMediateur obs) { |
| super("Filtres"); |
| observationMediateur = obs; |
| this.setCollapsible(true); |
| //this.setLayout(new AnchorLayout()) ; |
| this.setLayout(new RowLayout()); |
| rechercheLibreVue = new RechercheLibreVue(observationMediateur); |
| add(rechercheLibreVue,new RowLayoutData(75)); |
| rechercheLibreVue.setWidth("100%") ; |
| rechercheLibreVue.setBorder(false); |
| arbreEntiteGeographiqueObservationFiltreVue = new ArbreEntiteGeographiqueObservationFiltreVue(observationMediateur); |
| add(arbreEntiteGeographiqueObservationFiltreVue,new RowLayoutData()); |
| //arbreEntiteGeographiqueObservationFiltreVue.setHeight(300) ; |
| arbreEntiteGeographiqueObservationFiltreVue.setWidth("100%") ; |
| arbreEntiteGeographiqueObservationFiltreVue.setBorder(false); |
| arbreDateObservationFiltreVue = new ArbreDateObservationFiltreVue(observationMediateur) ; |
| //arbreDateObservationFiltreVue.setHeight(300) ; |
| add(arbreDateObservationFiltreVue, new RowLayoutData()); |
| arbreDateObservationFiltreVue.setWidth("100%") ; |
| arbreDateObservationFiltreVue.setBorder(false); |
| arbreMotsClesFiltreVue = new ArbreMotsClesFiltreVue(observationMediateur); |
| add(arbreMotsClesFiltreVue, new RowLayoutData()); |
| arbreMotsClesFiltreVue.setWidth("100%") ; |
| arbreMotsClesFiltreVue.setTitle("Mots Clés"); |
| arbreMotsClesFiltreVue.setTitleCollapse(true); |
| arbreMotsClesFiltreVue.setCollapsible(true); |
| arbreMotsClesFiltreVue.setBorder(false); |
| arbreMotsClesFiltreVue.hide(); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue getArbreEntiteGeographiqueObservationFiltreVue() { |
| return arbreEntiteGeographiqueObservationFiltreVue; |
| } |
| public ArbreDateObservationFiltreVue getArbreDateObservationFiltreVue() { |
| return arbreDateObservationFiltreVue; |
| } |
| public ArbreMotsClesFiltreVue getArbreMotsClesFiltreVue() { |
| return arbreMotsClesFiltreVue; |
| } |
| public RechercheLibreVue getRechercheLibreVue() { |
| return rechercheLibreVue; |
| } |
| /** |
| * 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 (arbreEntiteGeographiqueObservationFiltreVue.renvoyerEtatFiltre() || arbreDateObservationFiltreVue.renvoyerEtatFiltre() || rechercheLibreVue.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[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreMotsClesFiltreVue.renvoyerValeursAFiltrer(), |
| rechercheLibreVue.renvoyerValeursAFiltrer() |
| }; |
| return filtres; |
| } |
| } |
| /trunk/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java |
|---|
| New file |
| 0,0 → 1,104 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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 MenuObservationVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur; |
| /** |
| * Item pour la suppression d'obs |
| */ |
| private Item supprimerObservation = null; |
| private Item transmettreObservation = null; |
| private Item deTransmettreObservation = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuObservationVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| transmettreObservation = new Item("Rendre publiques les observations séléctionnées"); |
| addItem(transmettreObservation); |
| deTransmettreObservation = new Item("Rendre privées les observations séléctionnées"); |
| addItem(deTransmettreObservation); |
| supprimerObservation = new Item("Supprimer les observations séléctionnées"); |
| addItem(supprimerObservation); |
| // 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 |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(supprimerObservation)) { |
| // on notifie le médiateur |
| getOMediateur().supprimerObservations(); |
| } |
| // si c'est la transmission |
| if (item.equals(transmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(true); |
| } |
| // si c'est la detransmission |
| if (item.equals(deTransmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(false); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /trunk/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java |
|---|
| New file |
| 0,0 → 1,247 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.maps.client.InfoWindow; |
| import com.google.gwt.maps.client.InfoWindowContent; |
| import com.google.gwt.maps.client.MapType; |
| import com.google.gwt.maps.client.MapWidget; |
| import com.google.gwt.maps.client.control.LargeMapControl; |
| import com.google.gwt.maps.client.event.MarkerClickHandler; |
| import com.google.gwt.maps.client.event.MarkerDragEndHandler; |
| import com.google.gwt.maps.client.event.MarkerDragStartHandler; |
| import com.google.gwt.maps.client.event.MarkerDragEndHandler.MarkerDragEndEvent; |
| import com.google.gwt.maps.client.event.MarkerDragStartHandler.MarkerDragStartEvent; |
| import com.google.gwt.maps.client.geom.LatLng; |
| import com.google.gwt.maps.client.overlay.Marker; |
| import com.google.gwt.maps.client.overlay.MarkerOptions; |
| import com.google.gwt.user.client.Window; |
| 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.RegionPosition; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListener; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.form.Label; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.gwtext.client.widgets.map.LatLonPoint; |
| public class CartographieObservationVue extends Panel implements Rafraichissable { |
| private String id = "cartographie_observation"; |
| private ObservationMediateur oMediateur = null; |
| Panel panneauCarto = null; |
| private MapWidget map; |
| private boolean carteAjoutee = false; |
| private boolean requeteEnCours = false; |
| String valeurCommune = "Bourges"; |
| LatLng centreFrance = LatLng.newInstance(47.0504, 2.2347); |
| LatLng pointCommune = centreFrance; |
| String codeCommune = ""; |
| int niveauZoom = 9; |
| Label panneauExplication = new Label( |
| "Précisez le lieu de votre observation et cliquez sur OK. Les coordonnées sont données en degrés décimaux, comptés positivement vers le Nord pour la latitude, et vers l'Est pour la longitude"); |
| private InfoWindow info; |
| public CartographieObservationVue(ObservationMediateur om) { |
| oMediateur = om; |
| setTitle("Carto"); |
| setAutoWidth(true); |
| setPaddings(10); |
| panneauCarto = new Panel(); |
| panneauCarto.setLayout(new FitLayout()); |
| setLayout(new RowLayout()); |
| //initialiserCarte(); |
| add(panneauExplication, new RowLayoutData(12)); |
| add(panneauCarto, new RowLayoutData()); |
| addListener(new ContainerListenerAdapter() { |
| public void onAfterLayout(Container c) { |
| if(!carteAjoutee) { |
| initialiserCarte(); |
| } |
| recentrerCarte(); |
| } |
| }); |
| panneauCarto.setAutoHeight(true); |
| } |
| public void masquerChargement(boolean masquer) { |
| if (masquer) { |
| ExtElement masked = Ext.get(id); |
| if (masked != null) { |
| masked.mask("Chargement"); |
| } |
| } else { |
| ExtElement masked = Ext.get(id); |
| if (masked != null) { |
| masked.unmask(); |
| } |
| } |
| } |
| public void obtenirInfosCommunes(LatLng coord) { |
| oMediateur.obtenirInformationCoord(this, coord); |
| } |
| public void mettreAJourInfos(final LatLng pointNouvelleCommune, String infosComplementaires, int zoom) { |
| if (!carteAjoutee) { |
| initialiserCarte(); |
| } |
| pointCommune = pointNouvelleCommune; |
| map.clearOverlays(); |
| Marker nmk = fabriquerMarqueur(pointCommune, infosComplementaires); |
| map.addOverlay(nmk); |
| afficherInfoMarker(nmk); |
| recentrerCarte(); |
| } |
| public void initialiserCarte() { |
| map = new MapWidget(pointCommune, niveauZoom); |
| panneauCarto.add(map); |
| panneauCarto.doLayout(); |
| info = map.getInfoWindow(); |
| map.checkResizeAndCenter(); |
| map.setUIToDefault(); |
| map.addControl(new LargeMapControl()); |
| map.setCurrentMapType(MapType.getHybridMap()); |
| carteAjoutee = true; |
| panneauCarto.doLayout(); |
| } |
| public void AfficherMessageAucuneInfos() { |
| mettreAJourInfos(centreFrance,"", niveauZoom); |
| Window.alert("Aucune information pour le nom donné"); |
| } |
| public int getNiveauZoom() { |
| return niveauZoom; |
| } |
| private void ajouterListenerBouton(String idBouton) { |
| ExtElement bouton = Ext.get(idBouton); |
| bouton.addListener("click", new EventCallback() { |
| public void execute(EventObject e) { |
| EntiteGeographiqueObservation infosCommune = new EntiteGeographiqueObservation(codeCommune,valeurCommune,null); |
| infosCommune.setLat(pointCommune.getLatitude()+""); |
| infosCommune.setLon(pointCommune.getLongitude()+""); |
| oMediateur.rafraichirSaisieCommuneObservation(infosCommune); |
| } |
| }); |
| } |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof String) { |
| if(isVisible()) { |
| Window.alert((String)nouvelleDonnees); |
| } |
| } |
| if (nouvelleDonnees instanceof Object[]) { |
| Object[] infos = (Object[]) nouvelleDonnees; |
| LatLng coord = LatLng.newInstance((Double) infos[0], |
| (Double) infos[1]); |
| valeurCommune = (String)infos[3]; |
| codeCommune = (String)infos[2]; |
| mettreAJourInfos(coord, "", niveauZoom); |
| } |
| masquerChargement(false); |
| } |
| public Marker fabriquerMarqueur(LatLng pointMarqueur, final String texte) { |
| // ajout de marqueurs déplacables, qui affichent une bulle d'information |
| MarkerOptions options = MarkerOptions.newInstance(); |
| options.setDraggable(true); |
| final Marker marker = new Marker(pointMarqueur, options); |
| marker.addMarkerDragEndHandler(new MarkerDragEndHandler() { |
| public void onDragEnd(MarkerDragEndEvent event) { |
| afficherInfoMarker(marker); |
| } |
| }); |
| marker.addMarkerDragStartHandler(new MarkerDragStartHandler() { |
| public void onDragStart(MarkerDragStartEvent event) { |
| info.setVisible(false); |
| } |
| }); |
| marker.addMarkerClickHandler(new MarkerClickHandler() { |
| public void onClick(MarkerClickEvent event) { |
| if(info.isVisible()) { |
| info.close(); |
| } else { |
| afficherInfoMarker(marker); |
| } |
| } |
| }); |
| return marker; |
| } |
| public void recentrerCarte() { |
| //mettreAJourInfos(pointCommune,"", niveauZoom); |
| map.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 24)+"px"); |
| panneauCarto.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 12)+"px"); |
| map.setCenter(pointCommune, niveauZoom); |
| map.checkResizeAndCenter(); |
| } |
| public boolean isCarteAjoutee() { |
| return carteAjoutee; |
| } |
| public void afficherInfoMarker(Marker marker) { |
| final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>"; |
| info.open(marker, new InfoWindowContent("" |
| +valeurCommune+" ("+codeCommune+")<br />" |
| +"longitude=" |
| + marker.getLatLng().getLongitude() + "<br />latitude=" |
| + marker.getLatLng().getLatitude() + htmlBoutonOk)); |
| ajouterListenerBouton("okMap"); |
| } |
| } |