WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java

 package org.tela_botanica.client.vues.observation.filtres;
 import java.util.Comparator;
 import java.util.Iterator;
 import org.tela_botanica.client.interfaces.Filtrable;
 import org.tela_botanica.client.interfaces.Rafraichissable;
 import org.tela_botanica.client.modeles.EntiteGeographiqueObservation;
 import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;
 import org.tela_botanica.client.modeles.Observation;
 import org.tela_botanica.client.observation.ObservationMediateur;
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.user.client.Window;
 import com.gwtext.client.data.Node;
 import com.gwtext.client.data.NodeTraversalCallback;
 import com.gwtext.client.data.Tree;
 import com.gwtext.client.widgets.Component;
 import com.gwtext.client.widgets.Panel;
 import com.gwtext.client.widgets.event.PanelListenerAdapter;
 import com.gwtext.client.widgets.tree.TreeNode;
 import com.gwtext.client.widgets.tree.TreePanel;
 import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
 import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 import com.gwtext.client.core.EventObject;
 /**
  * Arbre Filtrant sur les entites geographiques
+ *
+ *
  * @author aurelien + david
+ *
  */
 public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,
 		Filtrable {
 	/**
 	 * Le médiateur associé à la vue
 	 */
 	private ObservationMediateur	observationMediateur		= null;
 	/**
 	 * Les localites en cours
 	 */
 	private String entitesGeographiquesEncours = "";
 	/**
 	 * Le treepanel qui affiche l'arbre
 	 */
 	private TreePanel arbreEntitesGeographiques = null;
 	/**
 	 * booléen d'initialisation
 	 */
 	private boolean estInstancie = false;
 	/**
 	 * booléen d'etat
 	 */
 	private boolean filtreModifie = false;
 	private boolean arbreCharge = false ;
 	private String nomFiltre = "" ;
 	/**
 	 * Constructeur sans argument (privé car ne doit pas être utilisé)
 	 */
 	@SuppressWarnings("unused")
 	private ArbreEntiteGeographiqueObservationFiltreVue() {
 		super();
+	}
 	/**
 	 * Constructeur avec paramètres
+	 *
 	 * @param im
 	 *            le médiateur à associer
 	 */
 	public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {
 		// on crée le panel
 		super("Localités");
 		this.observationMediateur = obs;
 		arbreEntitesGeographiques = new TreePanel();
 		this.setPaddings(5);
 		this.setCollapsible(true);
 		this.setAutoScroll(true);
 		// on ajoute les listeners
 		ajouterListenersPanel();
 		estInstancie = false;
+	}
 	/**
 	 * Ajoute les listeners pour le rendu du panel
 	 */
 	private void ajouterListenersPanel() {
 		  this.addListener(new PanelListenerAdapter() {
 			// on instancie réellement les composants au moment du rendu pour
 			// accélérer l'affichage
 			// et éviter des bugs
 			public void onRender(Component component) {
 				// on interdit le drag and drop dans l'arbre
 				arbreEntitesGeographiques.setEnableDD(false);
 				arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
 				// on crée une racine pour l'arbre
 				TreeNode root = new TreeNode("Localités");
 				root.setId("racine_entite");
 				String[] usObject = { "Localités" };
 				root.setUserObject(usObject);
 				arbreEntitesGeographiques.setRootNode(root);
 				arbreEntitesGeographiques.setRootVisible(true);
 				arbreEntitesGeographiques.setBorder(false);
 				root.setExpandable(true) ;
 				add(arbreEntitesGeographiques);
 				// on ajoute les listeners d'évenements
 				ajouterListeners();
 				// enfin on considère le composant comme instancié
 				estInstancie = true;
+			}
 		});
+	}
 	/**
 	 * ajoute les listeners pour les boutons et le cochage des entites
 	 */
 	private void ajouterListeners() {
 		arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() {
 			public void onClick(TreeNode node, EventObject e) {
-				nomFiltre = "" ;
-				entitesGeographiquesEncours = "" ;
-				String nomPere = "" ;
-				String nomGrandPere = "" ;
-				String nomArriereGrandPere = "";
-				switch(node.getDepth())
-				{
-					case 0:
-						if(!arbreCharge)
-						{
-							arbreEntitesGeographiques.getRootNode().expand();
-						}
-						else
-						{
-							observationMediateur.obtenirNombreObservation() ;
-						}
-						return ;
-					case 4: nomFiltre += "station,lieudit,location,id_location";
-					nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
-					nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
-					nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ;
-					entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ;
-					break;
-					case 3: nomFiltre += "lieudit,location,id_location";
-						nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
-						nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
-						entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ;
-						break;
-					case 2: nomFiltre += "location,id_location";
-						nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
-						entitesGeographiquesEncours += node.getText()+","+nomPere ;
-						break;
-					case 1: nomFiltre += "id_location";
-						entitesGeographiquesEncours += node.getText() ;
-						break;
-					default:
-						break;
-				}
-				filtreModifie = true ;
+				gererClicNoeud(node);
-				// Le filtre est modifie : on lance un rafraaaichissement de la liste des observations affichees
-				observationMediateur.obtenirNombreObservation() ;
+			}
 		}) ;
 		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
 			public void onExpand(Node node) {
 				if(!arbreCharge)
+				{
 					observationMediateur.obtenirListeEntiteGeographique() ;
 					arbreCharge = true ;
+				}
+			}
 		}) ;
+	}
+	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,location,id_location";
+			nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
+			nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
+			nomArriereGrandPere = ((String[])node.getParentNode().getParentNode().getParentNode().getUserObject())[0] ;
+			entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere+","+nomArriereGrandPere ;
+			break;
+			case 3: nomFiltre += "lieudit,location,id_location";
+				nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
+				nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[0] ;
+				entitesGeographiquesEncours += node.getText()+","+nomPere+","+nomGrandPere ;
+				break;
+			case 2: nomFiltre += "location,id_location";
+				nomPere = ((String[])node.getParentNode().getUserObject())[0] ;
+				entitesGeographiquesEncours += node.getText()+","+nomPere ;
+				break;
+			case 1: nomFiltre += "id_location";
+				entitesGeographiquesEncours += node.getText() ;
+				break;
+			default:
+				break;
+		}
+		filtreModifie = true ;
+	}
 	public void initialiser() {
 		arbreCharge = false ;
 		entitesGeographiquesEncours = "";
 		arbreEntitesGeographiques.collapseAll();
 		// on vide l'ancien arbre
 		Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes();
 		for (int i = 0; i < rootChild.length; i++) {
 			rootChild[i].remove();
+		}
 		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
 			public void onExpand(Node node) {
 				if(!arbreCharge)
+				{
 					observationMediateur.obtenirListeEntiteGeographique() ;
 					arbreCharge = true ;
+				}
+			}
 		}) ;
+	}
 	/**
 	 * Méthode héritée de l'interface rafraichissable
 	 */
 	public void rafraichir(Object nouvelleDonnees,
 			boolean repandreRaffraichissement) {
 		if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
 			ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
 				// on crée un arbre vide
 				Tree nouvelArbre = new Tree() ;
 				TreeNode root = new TreeNode();
 				root.setId("racine_entite");
 				root.setText("Localités");
 				String[] usObjRoot = { "Localités"};
 				root.setUserObject(usObjRoot);
 				nouvelArbre.setRootNode(root);
 				// on vide tous les noeuds
 				arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {
 					public boolean execute(Node node) {
 						node.remove();
 						return true;
+					}
 				});
 			// on la parse et on récupère les informations qui nous interessent
 			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
 					EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next());
 					creerHierarchieNoeud(nouvelArbre ,root, ent);
 					doLayout();
+				}
 				copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode());
 				arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ;
 				// si l'arbre n'était pas encore considéré comme instancié
 				if (!estInstancie) {
 					// on signale que oui
 					estInstancie = true;
+				}
 				// l'état du filtre est réinitialisé
 				filtreModifie = false;
 				//show() ;
 				arbreEntitesGeographiques.doLayout();
+			}
 		if(nouvelleDonnees instanceof Observation)
+		{
 			// Cas d'ajout unitaire d'une observation
 			// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
 			// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
 			// de l'arbre
 			if(!arbreCharge) {
 				return;
+			}
 			Observation obs = (Observation)nouvelleDonnees ;
 			EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation());
 			creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent);
 			doLayout();
 			arbreEntitesGeographiques.doLayout() ;
+		}
+	}
 	/**
 	 * Accesseur pour le panneau contenant l'arbre
+	 *
 	 * @return le panneau de l'arbre des mots clés
 	 */
 	public TreePanel getArbreMotsCles() {
 		return arbreEntitesGeographiques;
+	}
 	/**
 	 * Méthode héritée de Filtrable renvoie le nom du filtre
 	 */
 	public String renvoyerNomFiltre() {
 		return "Localités";
+	}
 	/**
 	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
+	 *
 	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
 	 */
 	public String[] renvoyerValeursAFiltrer() {
 		valider();
 		String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ;
 		return valeursFiltrees;
+	}
 	/**
 	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
 	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
+	 *
 	 * @param ndPereOriginal
 	 *            le père des noeuds de l'arbre original
 	 * @param ndPereCopie
 	 *            le père qui va recevoir les copies
 	 */
 	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
 		if (ndPereCopie != null && ndPereOriginal != null) {
 			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 			for (int i = 0; i < ndNodeFils.length; i++) {
 				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
 				TreeNode child = new TreeNode(usObj[0]);
 				child.setUserObject(usObj);
 				child.setId(""+usObj[1]);
 				ndPereCopie.appendChild(child);
 				if (!ndNodeFils[i].isLeaf()) {
 					copierFilsNoeud(ndNodeFils[i], child);
+				}
+			}
+		}
+	}
 	/**
 	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
 	 */
 	public boolean renvoyerEtatFiltre() {
 		return filtreModifie;
+	}
 	public void valider() {
 		if (estInstancie) {
+		}
+	}
 	public Comparator<TreeNode> comparerNoeuds()
+	{
 		return new Comparator<TreeNode>() {
 			public int compare(TreeNode o1, TreeNode o2) {
 				if(o1.getText().equals("Inconnue")) {
 					return -1 ;
+				}
 				if(o2.getText().equals("Inconnue")) {
 					return 1 ;
+				}
 				if(o1.getDepth() == 1 && o2.getDepth() == 1)
+				{
 					String l1 = o1.getText() ;
 					String l2 = o2.getText() ;
 					if(l1.length() == 1) {
 						l1 = "0"+l1;
+					}
 					if(l2.length() == 1) {
 						l2 = "0"+l2;
+					}
 					Integer n1 = 0;
 					Integer n2 = 0;
 					try{
 						n1 = Integer.parseInt(l1) ;
 						n2 = Integer.parseInt(l2) ;
 					} catch(NumberFormatException ne)  {
 						n1 = 0;
 						n2 = 0;
+					}
 					return n1.compareTo(n2) ;
+				}
 				else
+				{
 					String n1 = o1.getId() ;
 					String n2 = o2.getId() ;
 					return  n1.compareToIgnoreCase(n2);
+				}
+			}
 		} ;
+	}
 	public void raz() {
 		arbreCharge = false ;
 		arbreEntitesGeographiques.collapseAll();
 		arbreEntitesGeographiques.clear() ;
 		// on crée une racine pour l'arbre
 		TreeNode root = new TreeNode("Localités");
 		root.setId("racine_entite");
 		String[] usObject = { "Localités" };
 		root.setUserObject(usObject);
 		arbreEntitesGeographiques.setRootNode(root);
 		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
 			public void onExpand(Node node) {
 				if(!arbreCharge)
+				{
 					observationMediateur.obtenirDatesObservation() ;
 					arbreCharge = true ;
+				}
+			}
 		}) ;
 		entitesGeographiquesEncours  = "";
+	}
 	private TreeNode creerNoeud(String id, String texte) {
 		TreeNode nouveauNoeud = new TreeNode();
 		nouveauNoeud.setId(""+(id));
 		nouveauNoeud.setText(texte);
 		String[] usObj = {texte,id+""};
 		nouveauNoeud.setUserObject(usObj);
 		return nouveauNoeud;
+	}
 	/**
+	 *
 	 * @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds
 	 * @param root le noeud racine auquel on concatène la hierarchie crée
 	 * @param ent l'entité géographique qui doit être décomposée en arborescence
 	 * @return
 	 */
 	private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) {
 		String idLocation=null;
 		String location=null;
 		String lieuDit=null;
 		String station=null;
 		idLocation=ent.getIdLocalite();
 		idLocation = idLocation.replaceAll("\"", "");
 		idLocation = idLocation.replace('\\',' ');
 		idLocation = idLocation.trim();
 		location=ent.getCommune();
 		lieuDit=ent.getLieuDit();
 		station=ent.getStation();
 		if(idLocation.contains("000null") || idLocation.equals(null) || (idLocation.trim()).equals("")) {
 			idLocation="Inconnue" ;
+		}
 		if(location.contains("000null") || location.equals(null) || (location.trim().equals(""))) {
 			location="Inconnue" ;
+		}
 		if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
 			lieuDit="Inconnue" ;
+		}
 		if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) {
 			station="Inconnue" ;
+		}
 		Node noeudMemeId = arbre.getNodeById(""+idLocation);
 		if(noeudMemeId == null) {
 			// on crée le noeud de l'identifiant location
 			noeudMemeId = creerNoeud(""+idLocation,idLocation);
 			root.appendChild(noeudMemeId) ;
+		}
 		// on teste si la localité existe
 		Node noeudMemeLoc = arbre.getNodeById(""+(idLocation+location));
 		if(noeudMemeLoc == null)
+		{
 			//  on crée le noeud de la location
 			noeudMemeLoc = creerNoeud(""+idLocation+location, location);
 			noeudMemeId.appendChild(noeudMemeLoc) ;
+		}
 		// on teste si le lieu dit existe
 		Node noeudMemeLieu = arbre.getNodeById(""+(idLocation+location+lieuDit));
 		if(noeudMemeLieu == null)
+		{
 			// on crée le noeud du lieu dit
 			noeudMemeLieu = creerNoeud(idLocation+location+lieuDit, lieuDit);
 			noeudMemeLoc.appendChild(noeudMemeLieu) ;
+		}
 		// on teste si la station existe
 		Node noeudMemeStation = arbre.getNodeById(""+(idLocation+location+lieuDit+station));
 		if(noeudMemeStation == null) {
 			// on crée le noeud de la station
 			noeudMemeStation = creerNoeud(idLocation+location+lieuDit+station,station);
 			noeudMemeLieu.appendChild(noeudMemeStation);
+		}
 		root.sort(comparerNoeuds()) ;
+	}
+	@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() {
+			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("id_location")) {
+			profondeur = 1;
+		}
+		if(nom.equals("location")) {
+			profondeur = 2;
+		}
+		if(nom.equals("lieudit")) {
+			profondeur = 3;
+		}
+		if(nom.equals("station")) {
+			profondeur = 4;
+		}
+		return profondeur;
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java – Rev 263 → 683