| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,683 |
| 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.objets.DateObservation; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.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 |
| @Override |
| 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() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| nomFiltre = "" ; |
| donneesDateEnCours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(arbreCharge) { |
| nomFiltre = ""; |
| donneesDateEnCours = ""; |
| } |
| break; |
| case 3: nomFiltre += "annee,mois,jour"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 2: nomFiltre += "annee,mois"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 1: nomFiltre += "annee"; |
| donneesDateEnCours += ((String[])node.getUserObject())[1] ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| arbreDonneesDates.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDate) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDate data = (ListeDate) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText("Dates"); |
| String[] usObjRoot = { "Dates", "Dates", "racine_date"}; |
| root.setUserObject(usObjRoot); |
| Tree nouvelArbre = new Tree(); |
| nouvelArbre.setRootNode(root); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| DateObservation ent=data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ; |
| jour= ent.getJour() ; |
| if(annee.contains("0000")) { |
| annee="Inconnue" ; |
| } |
| if(jour.contains("00")) { |
| jour="Inconnue" ; |
| } |
| Node noeudMemeAnnee = nouvelArbre.getNodeById(""+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() { |
| @Override |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // et on recopie le nouvel arbre |
| copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates |
| .getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!estInstancie) { |
| // on signale que oui |
| estInstancie = true; |
| } |
| // l'état du filtre est réinitialisé |
| filtreModifie = false; |
| //show() ; |
| doLayout(); |
| } |
| 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 = Util.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 |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Dates"; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String valeursFiltrees[] = {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) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.clear(); |
| TreeNode root = new TreeNode("Dates"); |
| root.setId("racine_date"); |
| String[] usObject = { "Dates", "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreDonneesDates.getSelectionModel().clearSelections(); |
| donneesDateEnCours = ""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("annee")) { |
| profondeur = 1; |
| } |
| if(nom.equals("mois")) { |
| profondeur = 2; |
| } |
| if(nom.equals("jour")) { |
| profondeur = 3; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
|---|
| New file |
| 0,0 → 1,764 |
| package org.tela_botanica.client.vues.observation.filtres; |
| 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.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.dd.DragData; |
| import com.gwtext.client.dd.DragDrop; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| import com.gwtext.client.widgets.tree.DropNodeCallback; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| import com.gwtext.client.widgets.tree.TreeDragData; |
| 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, Filtrable { |
| /** |
| * 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 ajouterMotCle = 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 nécessaire pour l'affichage |
| * |
| */ |
| private boolean estInstancie = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| private Component livue = null; |
| MultiSelectionModel msModel = null; |
| /** |
| * 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("Projets"); |
| this.setLayout(new VerticalLayout()); |
| oMediateur = om; |
| setBorder(false); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| } |
| /** |
| * 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 |
| @Override |
| public void onRender(Component component) { |
| livue = oMediateur.getListeObservation(); |
| // 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"); |
| msModel = new MultiSelectionModel(); |
| arbreMotsCles.setSelectionModel(msModel); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Projets"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Projets", "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| ajouterMotCle = new Button("Ajouter un projet"); |
| arbreMotsCles.add(te); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on interdit le drag and drop dans l'arbre |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| // on met en forme le layout |
| add(arbreMotsCles); |
| add(ajouterMotCle); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| configDragAndDrop(); |
| // on ajoute les listeners d'évenements |
| 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 |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| boolean multi = false; |
| if(e.hasModifier()) { |
| multi = true; |
| } |
| gererClicNoeud(node,multi); |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| montrerContextMenuArbre(node, e, getTe()); |
| } |
| // gestion du double clic sur un noeud |
| @Override |
| 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 |
| @Override |
| 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 |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| getOMediateur().deplacerMotCleDansArbre(node, |
| getArbreMotsCles().getTree()); |
| } |
| @Override |
| public boolean doBeforeNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, |
| TreeNode dropNode, |
| DropNodeCallback dropNodeCallback) { |
| if(dragData instanceof TreeDragData) { |
| return true; |
| } |
| String idMotCle = ((String[])target.getUserObject())[1]; |
| if(oMediateur.gererDDObsSurMotCle(target, dragData)) { |
| cocherMotCle(idMotCle); |
| return true; |
| } |
| return false; |
| } |
| @Override |
| public void onNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, TreeNode dropNode) { |
| } |
| }); |
| // gestion de la validation |
| ajouterMotCle.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudAjout; |
| if(noeuds.length > 0) { |
| noeudAjout = noeuds[noeuds.length - 1]; |
| } else { |
| noeudAjout = arbreMotsCles.getRootNode(); |
| } |
| ajouterNoeud(noeudAjout); |
| } |
| }); |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| arbreMotsCles.setDdGroup("ObsMotsClesGroup"); |
| //arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setEnableDrag(true); |
| arbreMotsCles.setEnableDrop(true); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("ObsMotsClesGroup"); |
| } |
| /** |
| * 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())) { |
| if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) { |
| // 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"); |
| // 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); |
| } |
| /** |
| * Fonction de gestion sur le clic sur le noeud |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node, boolean multi) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| } else { |
| if(multi) { |
| } |
| ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi); |
| oMediateur.obtenirNombreObservation(); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| public boolean execute(Node node) { |
| // on parcourt le tableau des mots clés |
| for (int i = 0; i < motsClesIds.length; i++) { |
| // si le mot clé fait partie des id à cocher on |
| // le coche |
| String usObject[] = (String[]) node |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| if (nodeId.equals(motsClesIds[i])) { |
| getArbreMotsCles().getNodeById(nodeId) |
| .getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
| return true; |
| } |
| } |
| if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .getUI().getTextEl().removeClassName("x-tree-node-text-kw"); |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| else { |
| motsClesEnAttente = motsClesIds ; |
| } |
| } |
| public void cocherMotCle(String motCleId) { |
| getArbreMotsCles().getNodeById(motCleId) |
| .getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| motsClesEnCours = ""; |
| arbreMotsCles.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| // 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 obs) |
| if (nouvelleDonnees instanceof String) { |
| String chaineMc = (String)nouvelleDonnees; |
| String[] motsClesIds = chaineMc.split(";"); |
| // 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 |
| cocherMotsCles(motsClesIds); |
| } |
| // si l'arbre n'est pas encore instancié on met les mots clés en |
| // attente |
| else { |
| motsClesEnAttente = motsClesIds; |
| } |
| } |
| } |
| private String genererIdMotCle(TreeNode nd) { |
| double IdMC = (nd.hashCode() + ((Math.random() * 10000) + 1)); |
| return ""+IdMC; |
| } |
| /** |
| * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
| * copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
| * |
| * @param ndPereOriginal |
| * le père des noeuds de l'arbre original |
| * @param ndPereCopie |
| * le père qui va recevoir les copies |
| */ |
| private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) { |
| if (ndPereCopie != null && ndPereOriginal != null) { |
| Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
| for (int i = 0; i < ndNodeFils.length; i++) { |
| String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
| TreeNode child = new TreeNode(usObj[0]); |
| child.setId(usObj[1]); |
| child.setUserObject(usObj); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreMotsCles.collapseAll(); |
| arbreMotsCles.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode("Projets"); |
| root.setId("racine_obs"); |
| String[] usObject = { "Projets", "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| motsClesEnCours = ""; |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String val = ""; |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for(int i = 0; i< noeuds.length ; i++) { |
| if(noeuds[i].getDepth() > 0) { |
| val += ";"+noeuds[i].getId(); |
| } |
| } |
| val = val.replaceFirst(";", ""); |
| String[] valeursFiltres = {"id_mots_cles", val}; |
| return valeursFiltres; |
| } |
| @Override |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void montrerContextMenuArbre(final TreeNode n, EventObject e, |
| TreeEditor te) { |
| Menu mn = new Menu(); |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item( |
| "Ajouter un projet"); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item( |
| "Supprimer projet"); |
| mn.addItem(ajoutN); |
| mn.addItem(suppN); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| if (item.equals(suppN)) { |
| supprimerNoeud(n); |
| } |
| if (item.equals(ajoutN)) { |
| ajouterNoeud(n); |
| } |
| } |
| }); |
| mn.showAt(e.getXY()); |
| } |
| @Override |
| public void viderFiltre() { |
| arbreMotsCles.getSelectionModel().clearSelections(); |
| motsClesEnCours = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java |
|---|
| New file |
| 0,0 → 1,116 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| public class RechercheLibreVue extends Panel implements Filtrable { |
| private ObservationMediateur oMediateur = null; |
| private TextField champRecherche = null; |
| private static String titrePanneau = "Recherche libre"; |
| private String valeurRecherchee= ""; |
| private Button boutonRechercher = null; |
| private boolean estModifie = true; |
| private final int KEY_ENTER = 13; |
| public RechercheLibreVue(ObservationMediateur om) { |
| super(titrePanneau); |
| oMediateur = om; |
| champRecherche = new TextField(); |
| champRecherche.setWidth("90%"); |
| boutonRechercher = new Button("Rechercher"); |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche libre"; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = "recherche"; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| } else { |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| @Override |
| public void valider() { |
| if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
| estModifie = true; |
| oMediateur.obtenirNombreObservation(); |
| } else { |
| estModifie = false; |
| } |
| } |
| public void raz() { |
| if(champRecherche.isCreated()) { |
| champRecherche.reset(); |
| valeurRecherchee = ""; |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| valeurRecherchee = ""; |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,642 |
| 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.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.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 |
| @Override |
| 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() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| 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,commune,departement"; |
| 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,commune,departement"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ; |
| break; |
| case 2: nomFiltre += "commune,departement"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[0] ; |
| entitesGeographiquesEncours += node.getText()+","+nomPere ; |
| break; |
| case 1: nomFiltre += "departement"; |
| entitesGeographiquesEncours += node.getText() ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = 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() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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() { |
| @Override |
| 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=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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| 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() { |
| @Override |
| 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 id_zone_geo=null; |
| String zone_geo=null; |
| String lieuDit=null; |
| String station=null; |
| // TODO creer une fonction plus efficace lors du passage au multi reférentiel |
| id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo()); |
| id_zone_geo = id_zone_geo.replaceAll("\"", ""); |
| id_zone_geo = id_zone_geo.replace('\\',' '); |
| id_zone_geo = id_zone_geo.trim(); |
| zone_geo = ent.getZoneGeo(); |
| lieuDit = ent.getLieuDit(); |
| station = ent.getStation(); |
| if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) { |
| id_zone_geo="Inconnue" ; |
| } |
| if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) { |
| zone_geo="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(""+id_zone_geo); |
| if(noeudMemeId == null) { |
| // on crée le noeud de l'identifiant zone_geo |
| noeudMemeId = creerNoeud(""+id_zone_geo,id_zone_geo); |
| root.appendChild(noeudMemeId) ; |
| } |
| // on teste si la localité existe |
| Node noeudMemeLoc = arbre.getNodeById(""+(id_zone_geo+zone_geo)); |
| if(noeudMemeLoc == null) |
| { |
| // on crée le noeud de la zone_geo |
| noeudMemeLoc = creerNoeud(""+id_zone_geo+zone_geo, zone_geo); |
| noeudMemeId.appendChild(noeudMemeLoc) ; |
| } |
| // on teste si le lieu dit existe |
| Node noeudMemeLieu = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit)); |
| if(noeudMemeLieu == null) |
| { |
| // on crée le noeud du lieu dit |
| noeudMemeLieu = creerNoeud(id_zone_geo+zone_geo+lieuDit, lieuDit); |
| noeudMemeLoc.appendChild(noeudMemeLieu) ; |
| } |
| // on teste si la station existe |
| Node noeudMemeStation = arbre.getNodeById(""+(id_zone_geo+zone_geo+lieuDit+station)); |
| if(noeudMemeStation == null) { |
| // on crée le noeud de la station |
| noeudMemeStation = creerNoeud(id_zone_geo+zone_geo+lieuDit+station,station); |
| noeudMemeLieu.appendChild(noeudMemeStation); |
| } |
| root.sort(comparerNoeuds()) ; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreEntitesGeographiques.getSelectionModel().clearSelections(); |
| entitesGeographiquesEncours =""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("departement")) { |
| profondeur = 1; |
| } |
| if(nom.equals("commune")) { |
| profondeur = 2; |
| } |
| if(nom.equals("lieudit")) { |
| profondeur = 3; |
| } |
| if(nom.equals("station")) { |
| profondeur = 4; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java |
|---|
| New file |
| 0,0 → 1,71 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.widgets.Panel; |
| public class LienExterneVue extends Panel implements Rafraichissable { |
| private ObservationMediateur oMediateur = null; |
| private String refTax = ""; |
| private String refTaxVersion = ""; |
| private String numTax = ""; |
| private String efloreBaseUrl = ""; |
| private Label titreLien = new Label("Voir la fiche eflore"); |
| public LienExterneVue(ObservationMediateur om) { |
| oMediateur = om; |
| refTax = om.getRefTaxSelectionne().getCode(); |
| refTaxVersion = om.getRefTaxSelectionne().getVersionCourte(); |
| efloreBaseUrl = Configuration.getLienEfloreBaseUrl(); |
| titreLien.setVisible(false); |
| setBorder(false); |
| titreLien.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(!numTax.trim().equals("")) { |
| Window.open("http://"+efloreBaseUrl+"/"+refTax+"-nn-"+numTax,"",""); |
| } |
| } |
| }); |
| titreLien.setStyleName("lien_actif"); |
| add(titreLien); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String && !((String)nouvelleDonnees).trim().equals("")) { |
| if(!titreLien.isVisible()) { |
| titreLien.setVisible(true); |
| } |
| numTax = (String)nouvelleDonnees; |
| } else { |
| titreLien.setVisible(false); |
| } |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,597 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.LoadEvent; |
| import com.google.gwt.event.dom.client.LoadHandler; |
| import com.google.gwt.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.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) ; |
| imgZoom.setConstrain(true); |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image() { |
| @Override |
| 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)) { |
| if(imgZoom.isVisible()) { |
| imgZoom.hide(); |
| } else { |
| 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 |
| */ |
| @Override |
| 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(getUrlMiniature(index)); |
| 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.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickHandler(new ClickHandler() { |
| // en cas de clic |
| @Override |
| public void onClick(ClickEvent event) { |
| 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() { |
| @Override |
| 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) ; |
| } |
| /** |
| * 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 = {(int)Math.round(XYresize[0]*0.85),(int)Math.round(XYresize[1]*0.85)} ; |
| return res; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = getUrlAgrandie(index); |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadHandler(new LoadHandler() { |
| @Override |
| public void onLoad(LoadEvent event) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration(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 String getUrlMiniature(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatGalerie(); |
| } |
| private String getUrlAgrandie(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatZoom(); |
| } |
| 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 |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,209 |
| 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() { |
| @Override |
| 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); |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| image.setPixelSize(150, 150); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| @Override |
| 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 height="+Window.getClientHeight()*0.75+"px src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,212 |
| 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 String urlImageMax = "" ; |
| 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() { |
| @Override |
| 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") ; |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| add(image); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String []) { |
| String [] lecteurDonnees = (String []) nouvelleDonnees; |
| urlImage=lecteurDonnees[0]; |
| urlImageMax=lecteurDonnees[1]; |
| 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()) |
| { |
| imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlImageMax+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java |
|---|
| New file |
| 0,0 → 1,89 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.ui.FileUpload; |
| import com.google.gwt.user.client.ui.FormPanel; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteEvent; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteHandler; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.HasAlignment; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.Hidden; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| public class FormulaireImportObservationVue { |
| private ObservationMediateur oMediateur = null; |
| private Window nPan = null; |
| private Hidden identifiant = null; |
| public FormulaireImportObservationVue(ObservationMediateur om) { |
| this.oMediateur = om; |
| nPan = new Window("Import d'observations"); |
| identifiant = new Hidden(); |
| identifiant.setName("utilisateur"); |
| identifiant.setValue(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| final FormPanel form = new FormPanel(); |
| final Button boutonValidation = new Button("envoyer"); |
| form.setEncoding(FormPanel.ENCODING_MULTIPART); |
| form.setMethod(FormPanel.METHOD_POST); |
| form.setWidth("275px"); |
| nPan.setWidth("275px"); |
| VerticalPanel holder = new VerticalPanel(); |
| FileUpload upload = new FileUpload(); |
| upload.setName("upload"); |
| holder.add(upload); |
| holder.add(boutonValidation); |
| holder.add(identifiant); |
| HTML lienVersDocumentModele = new HTML("<a href=\"modele_import.xls\">Télécharger le modèle de document </a>"); |
| holder.add(lienVersDocumentModele); |
| holder.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT); |
| boutonValidation.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| form.submit(); |
| } |
| }); |
| form.add(holder); |
| nPan.add(form); |
| form.setAction(Configuration.getServiceBaseUrl() + "/InventoryImportExcel"); |
| form.addSubmitCompleteHandler(new SubmitCompleteHandler() { |
| @Override |
| public void onSubmitComplete(SubmitCompleteEvent event) { |
| nPan.close(); |
| com.google.gwt.user.client.Window.alert(""+event.getResults()+" observations créees"); |
| oMediateur.obtenirDernierePageObservation(); |
| } |
| }); |
| } |
| public void afficher() { |
| nPan.show(); |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,897 |
| package org.tela_botanica.client.vues.observation; |
| import java.util.Iterator; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Ontologies; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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.dd.DragData; |
| import com.gwtext.client.dd.DragDropConfig; |
| import com.gwtext.client.dd.DragSource; |
| import com.gwtext.client.dd.DropTarget; |
| import com.gwtext.client.dd.DropTargetConfig; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| 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; |
| import com.gwtext.client.widgets.tree.TreeDragData; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| /** |
| * 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; |
| private ColumnConfig referentielTaxoObservation; |
| private ColumnConfig nomSaisiObservation; |
| private ColumnConfig nomRetenuObservation; |
| private ColumnConfig lieuObservation; |
| private ColumnConfig dateObservation; |
| private ColumnConfig ordreObservation; |
| private ColumnConfig abondanceObservation; |
| private ColumnConfig certitudeObservation; |
| 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 ; |
| private ColumnConfig phenologieObservation; |
| /** |
| * 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; |
| setId("x-list-obs"); |
| setHeader(true); |
| // on place la barre de pagination |
| bt = new BarrePaginationVue(this); |
| bt.setLabelElement("Observations"); |
| bt.setTaillePageParDefaut(20); |
| bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ; |
| Toolbar barreActions = new Toolbar(); |
| ToolbarButton publier = new ToolbarButton("Rendre publiques"); |
| publier.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(true); |
| } |
| }); |
| ToolbarButton privatiser = new ToolbarButton("Rendre privées"); |
| privatiser.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(false); |
| } |
| }); |
| ToolbarButton supprimer = new ToolbarButton("Supprimer"); |
| supprimer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.supprimerObservations(); |
| } |
| }); |
| ToolbarButton importer = new ToolbarButton("Importer"); |
| importer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.afficherFormulaireImportObservation(); |
| } |
| }); |
| ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>"); |
| barreActions.addButton(publier); |
| barreActions.addButton(privatiser); |
| barreActions.addSpacer(); |
| barreActions.addButton(supprimer); |
| barreActions.addSpacer(); |
| barreActions.addButton(importer); |
| barreActions.addSpacer(); |
| barreActions.addItem(exporter); |
| this.setTopToolbar(barreActions) ; |
| this.setBottomToolbar(bt); |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| this.setTitle("Observations") ; |
| modeleColonnes = new ColumnModel(getConfigColonnes()); |
| this.setColumnModel(modeleColonnes); |
| this.setAutoScroll(true); |
| this.setEnableColumnResize(true); |
| // creation du store |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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(); |
| configDragAndDrop(); |
| } |
| private ColumnConfig[] getConfigColonnes() { |
| // on construit le modèle de colonnes |
| // Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) |
| Renderer colRend = new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| String valeur = ""; |
| if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) { |
| valeur = value.toString() ; |
| } |
| return valeur; |
| } |
| } ; |
| Renderer dateRend = new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) { |
| return "" ; |
| } |
| else |
| { |
| String dateEntiere = value.toString() ; |
| String[] dateEtHeure = dateEntiere.split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| String[] dateFormateeTab = dateEtHeure[0].split("-",3); |
| return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ; |
| } |
| } |
| return value.toString() ; |
| } |
| } ; |
| etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| if(value.equals("1")) |
| { |
| return "<img src=\"tela.png\"/></img>" ; |
| } |
| else |
| { |
| return "" ; |
| } |
| } |
| }); |
| referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend); |
| nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend); |
| nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend); |
| lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend); |
| dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend); |
| abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend); |
| certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() { |
| @Override |
| public String render(Object value, CellMetadata cellMetadata, |
| Record record, int rowIndex, int colNum, Store store) { |
| return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude")); |
| } |
| }); |
| phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend); |
| ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend); |
| ColumnConfig[] cm = {etatObservation, referentielTaxoObservation, nomSaisiObservation, certitudeObservation, nomRetenuObservation, abondanceObservation, phenologieObservation, lieuObservation, dateObservation, ordreObservation}; |
| return cm; |
| } |
| /** |
| * Ajoute les listeners pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| this.addGridRowListener(new GridRowListenerAdapter() { |
| // gestion du clic sur une ligne |
| @Override |
| public void onRowClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur et on lui passe le numéro de ligne |
| Record rd = st.getAt(rowIndex); |
| String ordreObservation = rd.getAsString("ordre_observation") ; |
| observationMediateur.onClicListeObservation(rowIndex,ordreObservation); |
| } |
| // gestion du clic droit |
| @Override |
| public void onRowContextMenu(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu |
| e.stopEvent() ; |
| // on notifie le médiateur en lui passant l'évenement |
| observationMediateur.montrerContextMenu(e); |
| } |
| // gestion du double clic |
| @Override |
| public void onRowDblClick(GridPanel grid, int rowIndex, |
| EventObject e) { |
| // on notifie le médiateur en lui passant le numéro de ligne |
| observationMediateur.doubleClicListeObservation(rowIndex); |
| } |
| }); |
| this.addGridListener(new GridListenerAdapter() { |
| @Override |
| 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() { |
| @Override |
| public void onRender(Component c) { |
| ExtElement lienExport = Ext.get("lienExport") ; |
| lienExport.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations(); |
| } |
| }); |
| } |
| }); |
| this.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) { |
| doLayout(); |
| } |
| }); |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| setDdGroup("ObsMotsClesGroup"); |
| setEnableDragDrop(true); |
| setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier"); |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("ObsMotsClesGroup"); |
| dtc.setTarget(true); |
| DragDropConfig ddc = new DragDropConfig(); |
| //La drop target permet de gérer l'évenement onDrop sur l'élement courant |
| @SuppressWarnings("unused") |
| DropTarget tg = new DropTarget(this, dtc) |
| { |
| @Override |
| public boolean notifyDrop(DragSource source, EventObject e, DragData data){ |
| // si on reçoit des données provenant d'un arbre |
| // on les convertit |
| if(data instanceof TreeDragData) { |
| TreeDragData tdd = (TreeDragData)data ; |
| TreeNode treeNode = tdd.getTreeNode(); |
| String idMc = treeNode.getId(); |
| int index = getView().findRowIndex(e); |
| if(index < 0) { |
| return true; |
| } |
| Record obsRd = getStore().getRecordAt(index); |
| if(obsRd == null) { |
| return true; |
| } |
| String ordreObs = obsRd.getAsString("ordre_observation"); |
| if(ordreObs != null) { |
| observationMediateur.gererDDMotCleSurObs(ordreObs, idMc); |
| return true ; |
| } else { |
| return true; |
| } |
| } |
| return true; |
| } |
| @Override |
| public String notifyOver(DragSource source, EventObject e, DragData data){ |
| if(data instanceof TreeDragData) { |
| TreeDragData tdd = (TreeDragData)data ; |
| TreeNode treeNode = tdd.getTreeNode(); |
| String idMc = treeNode.getId(); |
| int index = getView().findRowIndex(e); |
| if(index < 0) { |
| return "x-dd-drop-nodrop"; |
| } |
| Record obsRd = getStore().getRecordAt(index); |
| if(obsRd == null) { |
| return "x-dd-drop-nodrop"; |
| } |
| String ordreObs = obsRd.getAsString("ordre_observation"); |
| if(ordreObs != null) { |
| return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc); |
| } |
| } |
| return "x-dd-drop-nodrop"; |
| } |
| }; |
| } |
| /** |
| * Méthode héritée de l'interface VueListable |
| * Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
| */ |
| @Override |
| public String[] getIdSelectionnees() { |
| Record[] selection = this.getSelectionModel().getSelections(); |
| int taille = selection.length; |
| String id_selection[] = new String[taille]; |
| for (int i = 0; i < selection.length; i++) { |
| id_selection[i] = selection[i].getAsString("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) { |
| 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 |
| */ |
| @Override |
| 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()][11]; |
| 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=data.get(it.next()); |
| observationData[i][0] = obs.getTransmis(); |
| observationData[i][1] = obs.getCodeCourtReferentielTaxo(); |
| observationData[i][2] = obs.getNomSaisi(); |
| observationData[i][3] = obs.getCertitude(); |
| observationData[i][4] = obs.getNomRetenu(); |
| observationData[i][5] = obs.getAbondance(); |
| observationData[i][6] = obs.getPhenologie(); |
| observationData[i][7] = Util.formaterLieu(obs, modeleLieu); |
| observationData[i][8] = obs.getDate(); |
| observationData[i][9] = obs.getNumeroOrdre(); |
| observationData[i][10] = obs.getNumeroNomenclaturalSaisi(); |
| i++ ; |
| } |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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]) ; |
| if(nbElements > 0) { |
| masquerChargement(); |
| observationMediateur.obtenirListeObservation(this); |
| } else { |
| this.rafraichir(new ListeObservation(0), false); |
| } |
| } |
| // 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) |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| if(!getTailleInitialisee()) { |
| if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) { |
| doLayout(); |
| setTailleInitialisee(); |
| } |
| } |
| } |
| private FieldDef[] getDefinitionChamps() { |
| // creation du store qui les contient |
| FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
| FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation"); |
| FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
| FieldDef defCertitudeObservation = new StringFieldDef("certitude"); |
| FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
| FieldDef defAbondanceObservation = new StringFieldDef("abondance"); |
| FieldDef defPhenologieObservation = new StringFieldDef("phenologie"); |
| 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, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defAbondanceObservation, |
| defPhenologieObservation, defLieuObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation }; |
| return defTab; |
| } |
| // 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) arrondi à l'entier superieur |
| double nPage = (1.0*nbElements)/(1.0*taillePage) ; |
| double nPageRound = Math.ceil(nPage) ; |
| Double nPageInt = new Double(nPageRound) ; |
| 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) ; |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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[][] filtresEnCours) { |
| String texteFiltresEnCours = ""; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours += " - "; |
| } |
| texteFiltresEnCours += "<span class=\"affichage_filtre\">"+ |
| transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+ |
| " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+ |
| "</span>"; |
| } |
| } |
| if(!texteFiltresEnCours.equals("")) { |
| texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>"; |
| } |
| this.setTitle("Observations"+texteFiltresEnCours) ; |
| for(int i = 0; i < filtresEnCours.length; i++) { |
| if(Util.filtreValide(filtresEnCours[i])) { |
| if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) { |
| Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| e.stopEvent(); |
| observationMediateur.viderFiltre(e.getTarget().getAttribute("rel")); |
| } |
| }); |
| } |
| } |
| } |
| } |
| private String transformerNomFiltre(String nomFiltre) { |
| if(nomFiltre.equals("departement")) { |
| nomFiltre = "departement"; |
| } |
| if(nomFiltre.equals("commune")) { |
| nomFiltre = "commune"; |
| } |
| if(nomFiltre.equals("nom_taxon")) { |
| nomFiltre = "recherche"; |
| } |
| if(nomFiltre.equals("id_mots_cles")) { |
| nomFiltre = "projets"; |
| } |
| return nomFiltre; |
| } |
| private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) { |
| String valeurFiltreTransformee = valeurFiltre; |
| if(nomFiltre.equals("id_mots_cles")) { |
| String[] tabMotsCles = valeurFiltre.split(";"); |
| String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles); |
| if(tabMotsClesTexte.length > 1) { |
| valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte); |
| } else { |
| valeurFiltreTransformee = tabMotsClesTexte[0]; |
| } |
| } |
| if(nomFiltre.equals("mois")) { |
| valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre)); |
| } |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue"); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue"); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue"); |
| return valeurFiltreTransformee; |
| } |
| public void raz() { |
| RecordDef rd = new RecordDef(getDefinitionChamps()); |
| 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; |
| } |
| } |
| public boolean getTailleInitialisee() { |
| return tailleInitialisee ; |
| } |
| public void setTailleInitialisee() { |
| tailleInitialisee = true; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java |
|---|
| New file |
| 0,0 → 1,196 |
| 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() { |
| @Override |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| ok.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| afficherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // oMediateur.afficherNuageMotsCles(); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| 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 |
| */ |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| oMediateur.obtenirNombreObservation(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| motsAChercher = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java |
|---|
| New file |
| 0,0 → 1,1984 |
| 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.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielNom; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Ontologies; |
| import org.tela_botanica.client.modeles.objets.ReferentielCommune; |
| import org.tela_botanica.client.modeles.objets.ReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.AutoCompletionRefComboBox; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.maps.client.geom.LatLng; |
| import com.google.gwt.user.client.Timer; |
| 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.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.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| 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.Label; |
| 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 ComboBox lieudit = null; |
| private ComboBox station = null; |
| private ComboBox 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; |
| private String codeInseeCommune = null; |
| private String referentielTaxo = null; |
| private String referentielGeo = null; |
| // Pour remise a zero partielle lors d'une validation |
| private enum Champs { |
| DATE, LIEUDIT, STATION, MILIEU, COMMENT, COMMUNE, ESPECE, TOUT, LATITUDE, LONGITUDE, ABONDANCE, CERTITUDE, REFERENTIELTAXO, PHENOLOGIE; |
| @Override |
| 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 LATITUDE: |
| return "latitude"; |
| case LONGITUDE: |
| return "longitude"; |
| case ABONDANCE: |
| return "abondance"; |
| case CERTITUDE: |
| return "identification"; |
| case REFERENTIELTAXO: |
| return "referentiel"; |
| case PHENOLOGIE: |
| return "phenologie"; |
| case TOUT: |
| return "date, commune, lieu dit, station, milieu, espèce, commentaire, latitude, longitude, abondance, identification, referentiel, phenologie"; |
| } |
| 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 selectionAbondance = false; |
| private boolean selectionCertitude = false; |
| private boolean selectionPhenologie = 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:latitude:longitude:date:espece:commentaire:abondance:identification:referentiel:phenologie"; |
| 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 boolean abondanceModifiee = false; |
| private boolean certitudeModifiee = false; |
| private boolean referentielTaxoModifie = false; |
| private boolean phenologieModifiee = 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 htmlCommunePanel = null; |
| private MultiFieldPanel coordPanel; |
| private TextField coordonnees; |
| private Label lienSelectionCommune = null; |
| private HTML afficherFormulaireLatLon; |
| private HTML basculerverscarto; |
| private boolean longlatAjoutee; |
| private boolean latModifiee; |
| private boolean longModifiee; |
| protected boolean rechercheCommuneEnCours = false; |
| private Timer tCoord; |
| final String resultTplRefPerso = "<div class=\"search-item-commune\">{element_referentiel}</div>"; |
| private ComboBox selecteurAbondance = null; |
| private ComboBox selecteurCertitude = null; |
| private ComboBox selecteurReferentielTaxo = null; |
| private ComboBox selecteurStadePheno = null; |
| /** |
| * 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 ; |
| referentielTaxo = obs.getRefTaxSelectionne().getCode(); |
| 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); |
| //création du panneau formulaire de gauche auquels on ajoute les champs |
| panneauPremierColonne = new Panel(); |
| panneauPremierColonne.setLayout(new FormLayout()); |
| panneauPremierColonne.setBorder(false); |
| //création du panneau formulaire de droite |
| 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.setItemSelector("div.search-item-commune"); |
| commune.setTypeAhead(true); |
| commune.setLoadingText("Recherche..."); |
| commune.setHideTrigger(true); |
| //création du lien "Accès carto" dans le formulaire |
| basculerverscarto = new HTML(" <a id=\"lien_carto\" href=\"#\" tabindex=\"2\">Localiser la commune</a>"); |
| basculerverscarto.addStyleName("lien_actif"); |
| //création info bulle sur le lien "accès carto" |
| ToolTip tip2 = new ToolTip(); |
| tip2.setHtml("Via une carte, obtenez les coordonnées (latitude/longitude) de votre observation "); |
| tip2.applyTo(basculerverscarto.getElement()); |
| //Sur une meme ligne, ajout de plusieurs champs |
| htmlCommunePanel = new MultiFieldPanel(); |
| int largeurCommune = Window.getClientWidth()/4; |
| htmlCommunePanel.addToRow(commune, largeurCommune); |
| htmlCommunePanel.addToRow(basculerverscarto, 160); |
| htmlCommunePanel.setBorder(false); |
| htmlCommunePanel.setId("x-commune-panel"); |
| panneauPremierColonne.add(htmlCommunePanel); |
| station = new AutoCompletionRefComboBox("Station", "station", observationMediateur, TypesReferentiels.REFERENTIEL_STATION) { |
| @Override |
| public void onModificationValeur() { |
| stationModifiee = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.STATION); |
| } |
| }; |
| panneauPremierColonne.add(station, new AnchorLayoutData("95%")); |
| latitude = new TextField("Lat", "lat"); |
| latitude.setGrowMax(70); |
| latitude.setAllowBlank(true); |
| longitude = new TextField("Lon", "lon"); |
| longitude.setGrowMax(70); |
| longitude.setAllowBlank(true); |
| lienSelectionCommune = new Label(""); |
| lienSelectionCommune.setId("conteneur_selection_commune"); |
| lienSelectionCommune.setStyleName("conteneur_selection_commune"); |
| lienSelectionCommune.addStyleName("lien_actif"); |
| // Panneau de type plusieurs champs de formulaire sur une meme ligne, où seront renseignés Lat/Lon |
| coordPanel = new MultiFieldPanel(); |
| coordPanel.setPaddings(0, 0, 0, 10); |
| coordPanel.setVisible(false); |
| final double largeur ; |
| largeur = 120; |
| coordPanel.addToRow(latitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(longitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(lienSelectionCommune, new ColumnLayoutData(largeur)); |
| lienSelectionCommune.addClass("lien_decale"); |
| coordPanel.setBorder(false); |
| //création du champs coordonnées |
| referentielGeo = Configuration.getReferentielGeo(); |
| 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 |
| afficherFormulaireLatLon = new HTML("<span style=\"padding-left:30px;\" class=\"conteneur_lien_afficher_lat_lon\">" + |
| "<a title=\"Lat / Lon sont les latitudes / longitudes, à remplir en degrés décimaux\" class=\"lien_actif\" id=\"lien_coord\" href=\"#\" tabindex=\"6\">Saisie Lat/Lon ("+referentielGeo+")</a>" + |
| "<span><span style=\"padding-left:20px\" class=\"conteneur_lien_localiser_lat_lon\">"+ |
| "<a title=\"Cliquez pour obtenir les coordonnées de votre observation à partir de la carte\" class=\"lien_actif\" id=\"lien_carto_coord\" href=\"#\" tabindex=\"7\">Localiser sur la carte</a>"+ |
| "</span>"); |
| //ajout d'un listener sur le lien "saisie X/Y" |
| coordPanel.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| surPremierAffichageCoordPanel(largeur); |
| } |
| }); |
| //Sur une meme ligne, ajout de plusieurs champs |
| final MultiFieldPanel htmlPanel = new MultiFieldPanel(); |
| htmlPanel.addToRow(coordonnees, 100); |
| htmlPanel.addToRow(afficherFormulaireLatLon, new ColumnLayoutData(0.9)); |
| htmlPanel.setBorder(false); |
| htmlPanel.setId("x-coord-panel"); |
| panneauPremierColonne.add(htmlPanel); |
| panneauPremierColonne.add(coordPanel); |
| date = new DateField("Date", "date", 200); |
| date.setAllowBlank(true); |
| formatDate = "d/m/Y"; |
| date.setFormat(formatDate) ; |
| date.setTitle("Date de l'observation au format jj/mm/aaaa"); |
| //date.setTabIndex(5); |
| panneauPremierColonne.add(date, new AnchorLayoutData("55%")); |
| // Selection d'un référentiel par défaut (le premier spécifié dans la config) |
| referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode(); |
| selecteurReferentielTaxo = new ComboBox(); |
| selecteurReferentielTaxo.setCls("champ-separation"); |
| selecteurReferentielTaxo.setLabel("Référentiel"); |
| selecteurReferentielTaxo.setStore(Ontologies.getValeursReferentiel()); |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| selecteurReferentielTaxo.setDisplayField("label") ; |
| selecteurReferentielTaxo.setValueField("valeur"); |
| selecteurReferentielTaxo.setEditable(false); |
| selecteurReferentielTaxo.setHideTrigger(false); |
| selecteurReferentielTaxo.setForceSelection(true); |
| espece=new ComboBox("Espèce","nom"); |
| final String resultTplEspece = "<div class=\"search-item-espece {indicateurNomRetenu}\">{nom}</div>"; |
| espece.setTpl(resultTplEspece); |
| espece.setMode(ComboBox.REMOTE); |
| espece.setItemSelector("div.search-item-espece"); |
| espece.setTypeAhead(true); |
| espece.setLoadingText("Recherche..."); |
| espece.setHideTrigger(true); |
| Panel panelSeparationPp = new Panel(); |
| panelSeparationPp.setHeight(15); |
| panelSeparationPp.setBorder(false); |
| panneauPremierColonne.add(panelSeparationPp); |
| panneauPremierColonne.add(selecteurReferentielTaxo, new AnchorLayoutData("50%")); |
| panneauPremierColonne.add(espece, new AnchorLayoutData("95%")); |
| selecteurAbondance = new ComboBox(); |
| selecteurAbondance.setCls("champ-separation"); |
| selecteurAbondance.setLabel("Abondance"); |
| selecteurAbondance.setStore(Ontologies.getValeursAbondance()); |
| selecteurAbondance.setDisplayField("label") ; |
| selecteurAbondance.setValueField("valeur"); |
| selecteurAbondance.setEditable(true); |
| selecteurAbondance.setHideTrigger(false); |
| selecteurAbondance.setForceSelection(false); |
| panneauPremierColonne.add(selecteurAbondance, new AnchorLayoutData("50%")); |
| lieudit = new AutoCompletionRefComboBox("Lieu-dit", "lieudit",observationMediateur,TypesReferentiels.REFERENTIEL_LIEU_DIT) { |
| @Override |
| public void onModificationValeur() { |
| lieuDitModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.LIEUDIT); |
| } |
| }; |
| panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%")); |
| milieu = new AutoCompletionRefComboBox("Milieu","milieu",observationMediateur,TypesReferentiels.REFERENTIEL_MILIEU) { |
| @Override |
| public void onModificationValeur() { |
| milieuModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.MILIEU); |
| } |
| }; |
| panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%")); |
| comment = new TextArea("Notes", "comment"); |
| comment.setAllowBlank(true); |
| comment.setHeight(50); |
| panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") ); |
| Panel panelSeparationPs = new Panel(); |
| panelSeparationPs.setHeight(39); |
| panelSeparationPs.setBorder(false); |
| panneauSecondeColonne.add(panelSeparationPs); |
| selecteurCertitude = new ComboBox(); |
| selecteurCertitude.setLabel("Identification"); |
| selecteurCertitude.setStore(Ontologies.getValeursCertitude()); |
| selecteurCertitude.setDisplayField("label") ; |
| selecteurCertitude.setValueField("valeur"); |
| selecteurCertitude.setEditable(true); |
| selecteurCertitude.setHideTrigger(false); |
| selecteurCertitude.setForceSelection(false); |
| panneauSecondeColonne.add(selecteurCertitude, new AnchorLayoutData("50%")); |
| selecteurStadePheno = new ComboBox(); |
| selecteurStadePheno.setLabel("Phénologie"); |
| selecteurStadePheno.setStore(Ontologies.getValeursPhenologie()); |
| selecteurStadePheno.setDisplayField("label") ; |
| selecteurStadePheno.setValueField("valeur"); |
| selecteurStadePheno.setEditable(true); |
| selecteurStadePheno.setHideTrigger(false); |
| selecteurStadePheno.setForceSelection(false); |
| panneauSecondeColonne.add(selecteurStadePheno, new AnchorLayoutData("50%")); |
| if (Window.getClientWidth() > Window.getClientHeight() || Window.getClientWidth() < 800) { |
| 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) ; |
| if (Ext.isIE()) { |
| panneauPremierColonne.setButtonAlign(Position.RIGHT); |
| panneauPremierColonne.addButton(boutonOK); |
| panneauSecondeColonne.setButtonAlign(Position.LEFT); |
| panneauPremierColonne.addButton(boutonAnnuler); |
| } |
| else { |
| panneauFormulaire.addButton(boutonOK); |
| panneauFormulaire.addButton(boutonAnnuler); |
| } |
| selecteurMode.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| // et on met la valeur à jour dans la combobox |
| comboBox.setValue(record.getAsString("nom_mode")); |
| setModification(record.getAsString("mode")) ; |
| } |
| }); |
| this.add(panneauFormulaire) ; |
| this.setTopToolbar(bt) ; |
| this.setAutoScroll(true); |
| panneauFormulaire.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) { |
| panneauIntermediaire.setWidth(rawWidth); |
| panneauIntermediaire.setHeight(rawHeight); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| htmlCommunePanel.doLayout(); |
| htmlPanel.doLayout(); |
| doLayout(); |
| } |
| }); |
| // on ajoute les listeners |
| ajouterListeners() ; |
| saisieTabindex(); |
| } |
| private void surPremierAffichageCoordPanel(final double largeur) { |
| ExtElement lienCoord = Ext.get("lien_coord"); |
| lienCoord.removeAllListeners(); |
| lienCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| coordPanel.setVisible(!coordPanel.isVisible()); |
| if(Ext.isIE()) { |
| latitude.focus(); |
| } |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }) ; |
| ExtElement lienCartoCoord = Ext.get("lien_carto_coord"); |
| lienCartoCoord.removeAllListeners(); |
| lienCartoCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| obtenirInformationCoord(); |
| } |
| }) ; |
| ExtElement lienCarto = Ext.get("lien_carto"); |
| lienCarto.removeAllListeners(); |
| lienCarto.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(commune.getValue() != null && !commune.getValue().equals("") && !getDepartement().equals("")) { |
| obtenirInformationCommune(); |
| longlatAjoutee = true; |
| } else { |
| Window.alert("Veuillez renseigner une commune et un numéro de département sous la forme : Commune (departement)"); |
| } |
| } |
| }); |
| if(!Ext.isIE() && Window.getClientWidth() < 1200) { |
| int largeurN = (int)largeur; |
| latitude.setWidth(largeurN+"px"); |
| longitude.setWidth(largeurN+"px"); |
| lienSelectionCommune.setWidth(largeurN+"px"); |
| } |
| } |
| private void ajouterListeners() |
| { |
| // Listener completion communne |
| final Rafraichissable r = this; |
| ListenerConfig listenerConfigCommune=new ListenerConfig(); |
| listenerConfigCommune.setDelay(200); |
| listenerConfigCommune.setStopPropagation(false); |
| listenerConfigCommune.setStopEvent(false); |
| date.addListener(new DatePickerListenerAdapter() { |
| @Override |
| public void onSelect(DatePicker dataPicker, Date date) { |
| dateModifiee = true; |
| } |
| }); |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(false); |
| ListenerConfig listenerConfigEspece=new ListenerConfig(); |
| listenerConfigEspece.setDelay(10); |
| listenerConfigEspece.setStopPropagation(false); |
| listenerConfigEspece.setStopEvent(false); |
| tCoord = new Timer() { |
| @Override |
| public void run() { |
| double[] coord = coordonneesValides(); |
| if(!rechercheCommuneEnCours && coord != null && (longModifiee || latModifiee)) { |
| rechercheCommuneEnCours = true; |
| Ext.get(lienSelectionCommune.getElement()).mask("recherche"); |
| observationMediateur.obtenirInformationCoord(r,LatLng.newInstance(coord[0], coord[1])); |
| } |
| } |
| }; |
| ajouterListenerChampEvenementsClavier(commune, listenerConfigCommune); |
| ajouterListenerChampEvenementsClavier(date); |
| ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo); |
| ajouterListenerChampEvenementsClavier(espece, listenerConfigEspece); |
| ajouterListenerChampEvenementsClavier(comment); |
| ajouterListenerChampEvenementsClavier(latitude); |
| ajouterListenerChampEvenementsClavier(longitude); |
| ajouterListenerChampEvenementsClavier(selecteurAbondance); |
| ajouterListenerChampEvenementsClavier(selecteurCertitude); |
| ajouterListenerChampEvenementsClavier(selecteurStadePheno); |
| ajouterListenerChampsCombobox(); |
| boutonOK.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(modification) { |
| if(masseModification) { |
| modifierObservationEnMasse(null); |
| } else { |
| modifierObservation() ; |
| } |
| } |
| else { |
| ajouterObservation(); |
| } |
| } |
| }); |
| boutonAnnuler.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(modification) |
| { |
| supprimerObservation() ; |
| } |
| else |
| { |
| raz(); |
| } |
| } |
| }); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| commune.focus(); |
| } |
| }); |
| } |
| private void ajouterListenerChampsCombobox() { |
| commune.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| commune.setValue(record.getAsString("commune")); |
| departement=record.getAsString("departement"); |
| codeInseeCommune=record.getAsString("codeInsee"); |
| selectionCommune=true; |
| commune.collapse(); |
| } |
| @Override |
| public void onExpand(ComboBox comboBox) { |
| comboBox.focus(); |
| } |
| }); |
| selecteurReferentielTaxo.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| referentielTaxo = record.getAsString("valeur"); |
| observationMediateur.setRefTaxSelectionne(index); |
| referentielTaxoModifie = true; |
| } |
| }); |
| espece.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| espece.setValue(record.getAsString("nom")); |
| numeroNom=record.getAsString("numeroNom"); |
| selectionEspece=true; |
| observationMediateur.obtenirImageInformationExternes(referentielTaxo, numeroNom); |
| } |
| }); |
| selecteurAbondance.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionAbondance=true; |
| abondanceModifiee = true; |
| } |
| }); |
| selecteurCertitude.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionCertitude=true; |
| certitudeModifiee = true; |
| } |
| }); |
| selecteurStadePheno.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionPhenologie=true; |
| phenologieModifiee = true; |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ, final ListenerConfig config) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }, config); |
| } |
| private void surEvenementClavier(EventObject e, TextField champ) { |
| 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: |
| surEvenementClavierToucheEntree(champ); |
| break; |
| default: |
| gererEvenementClavierDefaut(champ); |
| break; |
| } |
| } |
| private void surEvenementClavierToucheEntree(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| if(!selectionPhenologie) { |
| validerSaisie(Champs.PHENOLOGIE); |
| } else { |
| selectionPhenologie = false; |
| } |
| } |
| if(champ.equals(selecteurCertitude)) { |
| if(!selectionCertitude) { |
| validerSaisie(Champs.CERTITUDE); |
| } else { |
| selectionCertitude = false; |
| } |
| } |
| if(champ.equals(selecteurAbondance)) { |
| if(!selectionAbondance) { |
| validerSaisie(Champs.ABONDANCE); |
| } else { |
| selectionAbondance = false; |
| } |
| } |
| if(champ.equals(longitude)) { |
| validerSaisie(Champs.LONGITUDE); |
| } |
| if(champ.equals(latitude)) { |
| validerSaisie(Champs.LATITUDE); |
| } |
| if(champ.equals(espece)) { |
| if(selectionEspece) { |
| especeModifiee = true; |
| selectionEspece=false; |
| } |
| else { |
| validerSaisie(Champs.ESPECE); |
| } |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| validerSaisie(Champs.REFERENTIELTAXO); |
| } |
| if(champ.equals(date)) { |
| validerSaisie(Champs.DATE); |
| } |
| if(champ.equals(commune)) { |
| if(champ.equals(commune)) { |
| if (selectionCommune) { |
| communeModifiee= true; |
| selectionCommune=false; |
| } |
| else { |
| validerSaisie(Champs.COMMUNE); |
| } |
| } |
| } |
| } |
| private void gererEvenementClavierDefaut(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| selecteurStadePheno.setRawValue(selecteurStadePheno.getRawValue()); |
| selecteurStadePheno.setValue(selecteurStadePheno.getRawValue()); |
| phenologieModifiee = true; |
| selectionPhenologie = false; |
| } |
| if(champ.equals(selecteurCertitude)) { |
| selecteurCertitude.setRawValue(selecteurCertitude.getRawValue()); |
| selecteurCertitude.setValue(selecteurCertitude.getRawValue()); |
| certitudeModifiee = true; |
| selectionCertitude = false; |
| } |
| if(champ.equals(selecteurAbondance)) { |
| selecteurAbondance.setRawValue(selecteurAbondance.getRawValue()); |
| selecteurAbondance.setValue(selecteurAbondance.getRawValue()); |
| abondanceModifiee = true; |
| selectionAbondance = false; |
| } |
| if(champ.equals(longitude)) { |
| longModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(latitude)) { |
| latModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(comment)) { |
| commModifie = true; |
| } |
| if(champ.equals(espece)) { |
| numeroNom=""; |
| obtenirListeReferentielNom(); |
| especeModifiee = true; |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| referentielTaxoModifie = true; |
| } |
| if(champ.equals(date)) { |
| dateModifiee = true; |
| } |
| if(champ.equals(commune)) { |
| departement=""; |
| commune.collapse(); |
| obtenirListeReferentielCommune(); |
| communeModifiee= true; |
| } |
| } |
| /** |
| * 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) ; |
| } |
| @Override |
| 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()][3]; |
| 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=data.get(it.next()); |
| communeData[i][0]= ref.getCommune(); |
| communeData[i][1]= ref.getDepartement(); |
| communeData[i][2]= ref.getCodeInsee(); |
| i++ ; |
| } |
| // creation du store |
| FieldDef defCommune = new StringFieldDef("commune"); |
| FieldDef defDepartement = new StringFieldDef("departement"); |
| FieldDef defCodeInsee = new StringFieldDef("codeInsee"); |
| FieldDef[] defTab = { defCommune, defDepartement, defCodeInsee}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(communeData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| commune.setStore(store); |
| store.load(); |
| } |
| // 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()][3]; |
| 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=data.get(it.next()); |
| nomData[i][0]= ref.getNom(); |
| nomData[i][1]= ref.getNumeroNom(); |
| if (ref.getStatut().equals("3")) { |
| nomData[i][2]="nom_retenu"; |
| } |
| else { |
| nomData[i][2]=""; |
| } |
| i++ ; |
| } |
| FieldDef defNom = new StringFieldDef("nom"); |
| FieldDef defNumeroNom = new StringFieldDef("numeroNom"); |
| FieldDef indicateurNomRetenu = new StringFieldDef("indicateurNomRetenu"); |
| FieldDef[] defTab = { defNom, defNumeroNom, indicateurNomRetenu}; |
| RecordDef rd = new RecordDef(defTab); |
| final MemoryProxy dataProxy = new MemoryProxy(nomData); |
| final ArrayReader reader = new ArrayReader(rd); |
| Store store=new Store(dataProxy,reader); |
| espece.setStore(store); |
| store.load() ; |
| } |
| // 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); |
| } |
| 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 ; |
| if(rechercheCommuneEnCours) { |
| afficherIndicationCommune(infosComm); |
| } else { |
| rafraichirCommuneEtCoord(infosComm); |
| } |
| } |
| } |
| private void afficherIndicationCommune( |
| final EntiteGeographiqueObservation infosCom) { |
| String nCommune = ""; |
| if(infosCom != null && !infosCom.getZoneGeo().trim().equals("")){ |
| nCommune += infosCom.getZoneGeo(); |
| if(!infosCom.getIdZoneGeo().trim().equals("")) |
| nCommune += " ("+Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo())+")"; |
| lienSelectionCommune.setHtml("<a id=\"lien_selection_commune\" tabindex=\"9\">"+nCommune+"</a>"); |
| lienSelectionCommune.setStyleName("img-curseur-depl"); |
| Ext.get("lien_selection_commune").addListener("click",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| rafraichirCommune(infosCom); |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("keypress",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(e.getCharCode() == KEY_ENTER) { |
| rafraichirCommune(infosCom); |
| } |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("focus",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_commune").toggleClass("lien_sel"); |
| } |
| }); |
| Ext.get("lien_selection_commune").addListener("blur",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_commune").toggleClass("lien_sel"); |
| } |
| }); |
| } else { |
| if(rechercheCommuneEnCours) { |
| lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> Erreur de localisation </span>"); |
| } else { |
| lienSelectionCommune.setHtml("<span id=\"aucune_selection_commune\"> </span>"); |
| } |
| } |
| Ext.get(lienSelectionCommune.getElement()).unmask(); |
| rechercheCommuneEnCours = false; |
| } |
| private void rafraichirCommune(EntiteGeographiqueObservation infosCom) { |
| String nCommune = ""; |
| if(infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().equals("")) { |
| nCommune += infosCom.getZoneGeo(); |
| } |
| if(infosCom.getIdZoneGeo() != null && !infosCom.getIdZoneGeo().equals("")) { |
| String codeGeoFormate = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| nCommune += " ("+codeGeoFormate+")"; |
| departement = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| } |
| commune.setValue(nCommune); |
| communeModifiee = true; |
| } |
| private void rafraichirCommuneEtCoord(EntiteGeographiqueObservation infosCom) { |
| // on ne remplace la commune que si le champ était vide |
| if(commune.getRawValue() == null || commune.getRawValue().equals("")) { |
| rafraichirCommune(infosCom); |
| } |
| if(infosCom.getLat() != null && !infosCom.getLat().equals("")) { |
| latitude.setValue(infosCom.getLat()); |
| } |
| if(infosCom.getLon() != null && !infosCom.getLon().equals("")) { |
| longitude.setValue(infosCom.getLon()); |
| } |
| latModifiee = true; |
| longModifiee = true; |
| coordPanel.setVisible(true); |
| } |
| public void obtenirListeReferentielCommune() { |
| String com=commune.getText(); |
| com=com.replaceAll("%",""); |
| observationMediateur.obtenirListeReferentielCommune(this,com); |
| } |
| public void obtenirListeReferentielNom() { |
| String esp=espece.getText().replaceAll(" ","/*"); |
| esp=esp.replaceAll("%",""); |
| String referentiel = this.referentielTaxo; |
| observationMediateur.obtenirListeReferentielNom(this,referentiel ,esp); |
| } |
| protected void obtenirReferentielStation() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_STATION,station.getText()); |
| } |
| protected void obtenirListeReferentielMilieu() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_MILIEU,milieu.getText()); |
| } |
| protected void obtenirReferentielLieuDit() { |
| observationMediateur.obtenirListeReferentielPerso(this,TypesReferentiels.REFERENTIEL_LIEU_DIT,lieudit.getText()); |
| } |
| public void ajouterObservation() { |
| if(!Util.verifierDateFormatCel(date.getRawValue()) && !date.getRawValue().equals("")) { |
| Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa"); |
| date.setInvalidText("Date invalide"); |
| return; |
| } |
| if(departement != null) { |
| 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 = "" ; |
| } |
| } |
| } |
| } |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| String[] coords = getValeurCoordonnees(); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(Ontologies.getInfosReferentielNomParCode(referentielTaxo).getCodeVersionComplet()); |
| observationMediateur.ajouterObservation(obs); |
| } |
| private void modifierObservation() { |
| if(!Util.verifierDateFormatCel(date.getRawValue()) && !date.getRawValue().equals("")) { |
| Window.alert("Attention la date saisie est invalide, la date doit être au format jj/mm/aaaa"); |
| date.setInvalidText("Date invalide"); |
| return; |
| } |
| 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 = "" ; |
| } |
| } |
| } |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,commune.getText(),departement,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| obs.setNumeroOrdre(numeroOrdre); |
| String[] coords = getValeurCoordonnees(); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(getReferentielTaxo()); |
| observationMediateur.modifierObservation(obs); |
| selecteurMode.setValue("création"); |
| setModification("false"); |
| } |
| private void modifierObservationEnMasse(Champs champModifie) { |
| //TODO: factoriser |
| 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 latM = null; |
| String longM = null; |
| String abondanceM = null; |
| String certitudeM = null; |
| String referentielTaxoM = null; |
| String phenologieM = 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(); |
| dateM = Util.remplacerSeparateursDateFormatCel(dateM); |
| }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", ""); |
| } |
| if(latModifiee) { |
| latM = latitude.getText(); |
| }else { |
| champs = champs.replaceAll(":latitude", ""); |
| } |
| if(longModifiee) { |
| longM = longitude.getText(); |
| }else { |
| champs = champs.replaceAll(":longitude", ""); |
| } |
| if(abondanceModifiee && !selecteurAbondance.getRawValue().equals(VALEURS_MULTIPLES)) { |
| abondanceM = getAbondance(); |
| } else { |
| champs = champs.replaceAll(":abondance", ""); |
| } |
| if(certitudeModifiee && !selecteurCertitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| certitudeM = getCertitude(); |
| } else { |
| champs = champs.replaceAll(":identification", ""); |
| } |
| if(referentielTaxoModifie && !selecteurReferentielTaxo.getRawValue().equals(VALEURS_MULTIPLES)) { |
| referentielTaxoM = getReferentielTaxo(); |
| } else { |
| champs = champs.replaceAll(":referentiel", ""); |
| } |
| if(phenologieModifiee && !selecteurStadePheno.getRawValue().equals(VALEURS_MULTIPLES)) { |
| phenologieM = getPhenologie(); |
| } else { |
| champs = champs.replaceAll(":phenologie", ""); |
| } |
| 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); |
| obs.setLatitude(latM); |
| obs.setLongitude(longM); |
| obs.setAbondance(abondanceM); |
| obs.setCertitude(certitudeM); |
| obs.setReferentielTaxo(referentielTaxoM); |
| obs.setPhenologie(phenologieM); |
| 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(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } else { |
| idLoc = obs.getIdentifiantLocalite(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } |
| 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.setRawValue(Util.remplacerSautsDeligneMalEncodes(obs.getCommentaire())); |
| } |
| if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) { |
| if(!idLoc.equals("000null") && !idLoc.equals("")) { |
| 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("000null")) { |
| numeroOrdre = obs.getNumeroOrdre() ; |
| } |
| if(!obs.getLatitude().equals("null") && !obs.getLatitude().equals("000null") |
| && !obs.getLongitude().equals("null") && !obs.getLongitude().equals("000null")) { |
| latitude.setValue(obs.getLatitude()) ; |
| longitude.setValue(obs.getLongitude()) ; |
| } |
| selecteurAbondance.getStore().load(); |
| selecteurAbondance.setValue(obs.getAbondance()); |
| selecteurCertitude.getStore().load(); |
| selecteurCertitude.setValue(obs.getCertitude()); |
| selecteurStadePheno.getStore().load(); |
| selecteurStadePheno.setValue(obs.getPhenologie()); |
| selecteurReferentielTaxo.getStore().load(); |
| if(obs.getReferentielTaxo() != VALEURS_MULTIPLES) { |
| referentielTaxo = obs.getCodeCourtReferentielTaxo(); |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| } else { |
| referentielTaxo = ""; |
| selecteurReferentielTaxo.setRawValue(VALEURS_MULTIPLES); |
| } |
| } |
| 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 =""; |
| latitude.reset(); |
| longitude.reset(); |
| break; |
| case ESPECE: |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| case LATITUDE: |
| latitude.reset(); |
| afficherIndicationCommune(null); |
| break; |
| case LONGITUDE: |
| longitude.reset(); |
| afficherIndicationCommune(null); |
| break; |
| case ABONDANCE: |
| selecteurAbondance.setValue(""); |
| break; |
| case CERTITUDE: |
| selecteurCertitude.setValue(""); |
| break; |
| case REFERENTIELTAXO: |
| selecteurReferentielTaxo.setValue(""); |
| break; |
| case PHENOLOGIE: |
| selecteurStadePheno.setValue(""); |
| break; |
| case TOUT: |
| commune.reset(); |
| date.reset() ; |
| lieudit.reset() ; |
| station.reset() ; |
| milieu.reset() ; |
| comment.reset() ; |
| milieu.reset() ; |
| latitude.reset(); |
| longitude.reset(); |
| departement =""; |
| espece.reset(); |
| selecteurAbondance.clearValue(); |
| selecteurCertitude.clearValue(); |
| selecteurReferentielTaxo.clearValue(); |
| selecteurStadePheno.clearValue(); |
| referentielTaxo = ""; |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| afficherIndicationCommune(null); |
| 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("Créer") ; |
| 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 lat = null; |
| String lon = null; |
| String abondance = null; |
| String certitude = null; |
| String referentielTaxo = null; |
| String phenologie = 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()); |
| lat = comparerDifferencesChamps(lat, obsEnCours.getLatitude()); |
| lon = comparerDifferencesChamps(lon, obsEnCours.getLongitude()); |
| abondance = comparerDifferencesChamps(abondance, obsEnCours.getAbondance()); |
| certitude = comparerDifferencesChamps(certitude, obsEnCours.getCertitude()); |
| referentielTaxo = comparerDifferencesChamps(referentielTaxo, obsEnCours.getReferentielTaxo()); |
| phenologie = comparerDifferencesChamps(phenologie, obsEnCours.getPhenologie()); |
| ordreObs += obsEnCours.getNumeroOrdre()+","; |
| } |
| Observation obs=new Observation(espece,numeroNom,commune,departement,lieuDit,station,milieu, notes,date); |
| obs.setNumeroOrdre(ordreObs); |
| obs.setLatitude(lat); |
| obs.setLongitude(lon); |
| obs.setAbondance(abondance); |
| obs.setCertitude(certitude); |
| obs.setReferentielTaxo(referentielTaxo); |
| obs.setPhenologie(phenologie); |
| 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; |
| latModifiee = false; |
| longModifiee = false; |
| abondanceModifiee = false; |
| certitudeModifiee = false; |
| referentielTaxoModifie = false; |
| phenologieModifiee = false; |
| } |
| public void saisieTabindex() |
| { |
| selecteurMode.setTabIndex(0); |
| commune.setTabIndex(1); |
| lieudit.setTabIndex(3); |
| station.setTabIndex(4); |
| milieu.setTabIndex(5); |
| coordonnees.setTabIndex(-1); |
| coordonnees.addListener(new TextFieldListenerAdapter() { |
| @Override |
| public void onFocus(Field field) { |
| if(coordPanel.isVisible()) { |
| latitude.focus(); |
| } else { |
| Ext.get("lien_carto").focus(); |
| } |
| } |
| }); |
| latitude.setTabIndex(8); |
| longitude.setTabIndex(9); |
| comment.setTabIndex(10); |
| date.setTabIndex(11); |
| espece.setTabIndex(12); |
| selecteurCertitude.setTabIndex(13); |
| selecteurAbondance.setTabIndex(14); |
| selecteurStadePheno.setTabIndex(15); |
| boutonOK.setTabIndex(16); |
| boutonAnnuler.setTabIndex(17); |
| } |
| private void obtenirInformationCoord() { |
| if(coordonneesValides() != null) { |
| observationMediateur.obtenirInformationCoord(LatLng.newInstance(coordonneesValides()[0],coordonneesValides()[1])); |
| } else { |
| observationMediateur.afficherFenetreCarto(); |
| } |
| } |
| private void obtenirInformationCommune() { |
| observationMediateur.obtenirInformationCommune(getCommuneSansDepartement(), Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText())); |
| } |
| public 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[] getValeurCoordonnees() { |
| double[] coDouble = coordonneesValides(); |
| if(coDouble != null) { |
| String[] coord = {coDouble[0]+"",coDouble[1]+""}; |
| return coord; |
| } else { |
| String[] coord = {"000null","000null" }; |
| return coord; |
| } |
| } |
| public String getCommune() { |
| String valeurCommune = ""; |
| if(commune.getValue() != null) { |
| valeurCommune = commune.getValue(); |
| } |
| return valeurCommune; |
| } |
| public String getDepartement() { |
| return Util.obtenirDepartementAPartirChaineCommune(departement, commune.getText()); |
| } |
| public String getCommuneSansDepartement() { |
| return Util.supprimerNumDepartementChaineLocalite(getCommune()); |
| } |
| private String getValeurChampListeLibre(ComboBox champ) { |
| String valeurChamp = champ.getValue(); |
| String valeurChampBrute = champ.getRawValue(); |
| // Test idiot qui permet de savoir si l'on utilise la valeur saisie directement ou bien la valeur |
| // selectionnee car lors du setValue sur le keypress, gwtext ne prends pas en compte le dernier |
| // caractère |
| if(valeurChamp != null && valeurChamp.length() > 0) { |
| if(valeurChamp.equals(valeurChampBrute.substring(0, valeurChampBrute.length() -1))) { |
| valeurChamp = champ.getRawValue(); |
| } |
| } |
| return valeurChamp; |
| } |
| public String getAbondance() { |
| return getValeurChampListeLibre(selecteurAbondance); |
| } |
| public String getCertitude() { |
| return getValeurChampListeLibre(selecteurCertitude); |
| } |
| public String getPhenologie() { |
| return getValeurChampListeLibre(selecteurStadePheno); |
| } |
| public String getReferentielTaxo() { |
| String codeCourt = getValeurChampListeLibre(selecteurReferentielTaxo); |
| return Ontologies.getInfosReferentielNomParCode(codeCourt).getCodeVersionComplet(); |
| } |
| public boolean communeInitialisee() { |
| return communeModifiee; |
| } |
| public void redimensionnerFormulaire() { |
| afficherFormulaireLatLon.setWidth(panneauIntermediaire.getWidth()+"px"); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| panneauIntermediaire.doLayout(); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java |
|---|
| New file |
| 0,0 → 1,179 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| 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.ArbreMotsClesObservationVue; |
| import org.tela_botanica.client.vues.observation.filtres.RechercheLibreVue; |
| import com.gwtext.client.core.Ext; |
| 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 ArbreMotsClesObservationVue arbreMotsClesObservationVue = 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); |
| if(Ext.isIE()) { |
| add(rechercheLibreVue); |
| rechercheLibreVue.setHeight(110); |
| } else { |
| add(rechercheLibreVue,new RowLayoutData(100)); |
| } |
| 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); |
| arbreMotsClesObservationVue = new ArbreMotsClesObservationVue(observationMediateur); |
| add(arbreMotsClesObservationVue, new RowLayoutData()); |
| arbreMotsClesObservationVue.setWidth("100%") ; |
| arbreMotsClesObservationVue.setTitle("Projets"); |
| arbreMotsClesObservationVue.setTitleCollapse(true); |
| arbreMotsClesObservationVue.setCollapsible(true); |
| arbreMotsClesObservationVue.setBorder(false); |
| } |
| /** |
| * 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 ArbreMotsClesObservationVue getArbreMotsClesObservationVue() { |
| return arbreMotsClesObservationVue; |
| } |
| 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(), |
| arbreMotsClesObservationVue.renvoyerValeursAFiltrer(), |
| rechercheLibreVue.renvoyerValeursAFiltrer() |
| }; |
| return filtres; |
| } |
| public void viderFiltres() { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(); |
| arbreDateObservationFiltreVue.viderFiltre(); |
| arbreMotsClesObservationVue.viderFiltre(); |
| rechercheLibreVue.viderFiltre(); |
| } |
| public void viderFiltres(String nom) { |
| if(nom.equals("id_mots_cles")) { |
| arbreMotsClesObservationVue.viderFiltre(); |
| } |
| if(nom.equals("recherche")) { |
| rechercheLibreVue.viderFiltre(); |
| } |
| if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) { |
| arbreDateObservationFiltreVue.viderFiltre(nom); |
| } |
| if(nom.equals("station") || nom.equals("lieudit") || nom.equals("departement") || nom.equals("commune")) { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(nom); |
| } |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java |
|---|
| New file |
| 0,0 → 1,105 |
| 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 |
| @Override |
| 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 |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java |
|---|
| New file |
| 0,0 → 1,358 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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.Maps; |
| import com.google.gwt.maps.client.control.LargeMapControl; |
| import com.google.gwt.maps.client.event.MapClickHandler; |
| import com.google.gwt.maps.client.event.MapZoomEndHandler; |
| 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.geom.LatLng; |
| import com.google.gwt.maps.client.overlay.Marker; |
| import com.google.gwt.maps.client.overlay.MarkerOptions; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| 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.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.form.Label; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| 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 = null; |
| LatLng pointCommune = null; |
| String codeCommune = ""; |
| int niveauZoom = 6; |
| 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; |
| private boolean listenerInitialise = false; |
| public CartographieObservationVue(ObservationMediateur om) { |
| oMediateur = om; |
| setHeader(false); |
| setAutoWidth(true); |
| setPaddings(10); |
| panneauCarto = new Panel(); |
| panneauCarto.setLayout(new FitLayout()); |
| setLayout(new RowLayout()); |
| add(panneauExplication, new RowLayoutData(12)); |
| add(panneauCarto, new RowLayoutData()); |
| if(!carteAjoutee) { |
| Maps.loadMapsApi(Configuration.getCleGoogleMaps(), "2", false, new Runnable() { |
| @Override |
| public void run() { |
| initialiserCarte(false); |
| } |
| }); |
| } |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| if(carteAjoutee) { |
| panneauCarto.setHeight("100%"); |
| if((panneauCarto.getHeight() - 20) > map.getSize().getHeight()) { |
| map.setSize(map.getSize().getWidth()+"px", (panneauCarto.getHeight() - 20)+"px"); |
| } |
| panneauCarto.doLayout(); |
| panneauCarto.expand(); |
| } |
| } |
| }); |
| panneauCarto.setAutoHeight(true); |
| } |
| public void setTailleCarte(int hauteur, int largeur) { |
| map.setSize(largeur+"px", (hauteur+"px")); |
| } |
| public void masquerChargement(boolean masquer) { |
| if(panneauCarto.isVisible()) { |
| if(masquer) { |
| panneauCarto.getEl().mask("Recherche des coordonnées et de la commune, veuillez patienter"); |
| } else { |
| panneauCarto.getEl().unmask(); |
| } |
| } |
| } |
| public void obtenirInfosCommunes(LatLng coord) { |
| oMediateur.obtenirInformationCoord(this, coord); |
| } |
| public void mettreAJourInfos(final LatLng pointNouvelleCommune, String infosComplementaires, int zoom) { |
| if (!carteAjoutee) { |
| initialiserCarte(true); |
| } |
| pointCommune = pointNouvelleCommune; |
| map.clearOverlays(); |
| Marker nmk = fabriquerMarqueur(pointCommune, infosComplementaires); |
| map.addOverlay(nmk); |
| afficherInfoMarker(nmk); |
| recentrerCarte(); |
| } |
| public void initialiserCarte(boolean commune) { |
| centreFrance = LatLng.newInstance(47.0504, 2.2347); |
| pointCommune = centreFrance; |
| map = new MapWidget(pointCommune, niveauZoom); |
| panneauCarto.add(map); |
| panneauCarto.doLayout(); |
| info = map.getInfoWindow(); |
| if(!commune) { |
| fabriquerMarqueurIndication(); |
| } |
| map.setZoomLevel(6); |
| map.checkResizeAndCenter(); |
| map.setUIToDefault(); |
| map.addControl(new LargeMapControl()); |
| map.setCurrentMapType(MapType.getHybridMap()); |
| carteAjoutee = true; |
| panneauCarto.doLayout(); |
| map.addMapClickHandler(new MapClickHandler() { |
| @Override |
| public void onClick(MapClickEvent event) { |
| //TODO : quoi faire du double clic ? |
| obtenirInfosCommunes(event.getLatLng()); |
| } |
| }); |
| map.addMapZoomEndHandler(new MapZoomEndHandler() { |
| @Override |
| public void onZoomEnd(MapZoomEndEvent event) { |
| niveauZoom = event.getNewZoomLevel(); |
| } |
| }); |
| } |
| public void fabriquerMarqueurIndication() { |
| Marker marker = fabriquerMarqueur(pointCommune,""); |
| map.addOverlay(marker); |
| info.open(marker, new InfoWindowContent("<div id=\"info_contenu\">"+ |
| "Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />" |
| +"longitude=" |
| + marker.getLatLng().getLongitude() + "<br />latitude=" |
| + marker.getLatLng().getLatitude() + "</div>")); |
| } |
| public void AfficherMessageAucuneInfos() { |
| mettreAJourInfos(centreFrance,"", niveauZoom); |
| Window.alert("Aucune information pour le nom donné"); |
| } |
| public int getNiveauZoom() { |
| return niveauZoom; |
| } |
| private void ajouterListenerBouton(final String idBouton) { |
| final ExtElement bouton = Ext.get(idBouton); |
| if(bouton == null) { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| ajouterListenerBouton(idBouton); |
| } |
| }; |
| t.schedule(500); |
| return; |
| } |
| bouton.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| EntiteGeographiqueObservation infosCommune = new EntiteGeographiqueObservation(codeCommune,valeurCommune,null,null); |
| infosCommune.setLat(pointCommune.getLatitude()+""); |
| infosCommune.setLon(pointCommune.getLongitude()+""); |
| oMediateur.rafraichirSaisieCommuneObservation(infosCommune); |
| } |
| }); |
| bouton.focus(); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof String) { |
| if(isVisible()) { |
| Window.alert((String)nouvelleDonnees); |
| } |
| } |
| if (nouvelleDonnees instanceof EntiteGeographiqueObservation) { |
| oMediateur.afficherFenetreCarto(); |
| EntiteGeographiqueObservation infos = (EntiteGeographiqueObservation) nouvelleDonnees; |
| Double lat = 0.0; |
| Double lon = 0.0; |
| try { |
| lat = Double.parseDouble(infos.getLat()); |
| lon = Double.parseDouble(infos.getLon()); |
| } catch (NumberFormatException nbe) { |
| } |
| LatLng coord = LatLng.newInstance(lat, lon); |
| valeurCommune = infos.getZoneGeo(); |
| codeCommune = Util.convertirChaineZoneGeoVersDepartement(infos.getIdZoneGeo()); |
| pointCommune = coord; |
| 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() { |
| @Override |
| public void onDragEnd(MarkerDragEndEvent event) { |
| masquerChargement(true); |
| obtenirInfosCommunes(marker.getLatLng()); |
| } |
| }); |
| marker.addMarkerDragStartHandler(new MarkerDragStartHandler() { |
| @Override |
| public void onDragStart(MarkerDragStartEvent event) { |
| info.setVisible(false); |
| } |
| }); |
| marker.addMarkerClickHandler(new MarkerClickHandler() { |
| @Override |
| public void onClick(MarkerClickEvent event) { |
| if(info.isVisible()) { |
| info.close(); |
| } else { |
| afficherInfoMarker(marker); |
| } |
| } |
| }); |
| return marker; |
| } |
| public void recentrerCarte() { |
| if(this.getWidth() > 12 && this.getHeight() > 24) { |
| 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>"; |
| String contenuMarker = ""; |
| if(valeurCommune == null || valeurCommune.trim().equals("")) { |
| if(marker.getLatLng().getLongitude() == 0 && marker.getLatLng().getLatitude() == 0) { |
| LatLng point = centreFrance; |
| marker.setLatLng(point); |
| niveauZoom = 6; |
| } |
| contenuMarker = "<div id=\"info_contenu\">"+ |
| "Aucune commune française trouvée à cet emplacement <br />" |
| +"Déplacez ce marqueur pour localiser votre observation (commune et coordonnées)<br />" |
| +"longitude=" |
| + marker.getLatLng().getLongitude() + "<br />latitude=" |
| + marker.getLatLng().getLatitude() + "</div>"; |
| } else { |
| contenuMarker = "" |
| +valeurCommune+" ("+codeCommune+")<br />" |
| +"longitude=" |
| + marker.getLatLng().getLongitude() + "<br />latitude=" |
| + marker.getLatLng().getLatitude() ; |
| } |
| info.open(marker, new InfoWindowContent("" |
| + contenuMarker |
| + htmlBoutonOk)); |
| recentrerCarte(); |
| ajouterListenerBouton("okMap"); |
| } |
| public LatLng getCentreFrance() { |
| return LatLng.newInstance(47.0504, 2.2347); |
| } |
| } |
| /branches/v1.6-croc/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,211 |
| 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() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| motsAAjouter = motsClesAjout.getText(); |
| //oMediateur.AjouterMotsClesEnMasse(motsAAjouter); |
| } |
| }); |
| voirCacherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| 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 |
| } |
| @Override |
| 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) { |
| @Override |
| 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 |