Subversion Repositories eFlore/Applications.cel

Rev

Rev 2624 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
199 david 1 
package org.tela_botanica.client.vues.observation.filtres;
54 david 2 
 
90 jpm 3 
import java.util.Comparator;
68 david 4 
import java.util.Iterator;
5 
 
2622 mathias 6 
import org.tela_botanica.client.i18n.Msg;
54 david 7 
import org.tela_botanica.client.interfaces.Filtrable;
8 
import org.tela_botanica.client.interfaces.Rafraichissable;
989 aurelien 9 
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
10 
import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation;
11 
import org.tela_botanica.client.modeles.objets.Observation;
54 david 12 
import org.tela_botanica.client.observation.ObservationMediateur;
965 aurelien 13 
import org.tela_botanica.client.util.Util;
54 david 14 
 
15 
import com.gwtext.client.data.Node;
16 
import com.gwtext.client.data.NodeTraversalCallback;
17 
import com.gwtext.client.data.Tree;
18 
import com.gwtext.client.widgets.Component;
19 
import com.gwtext.client.widgets.Panel;
20 
import com.gwtext.client.widgets.event.PanelListenerAdapter;
21 
import com.gwtext.client.widgets.tree.TreeNode;
22 
import com.gwtext.client.widgets.tree.TreePanel;
87 jpm 23 
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
85 jpm 24 
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
25 
import com.gwtext.client.core.EventObject;
54 david 26 
 
27 
/**
199 david 28 
 * Arbre Filtrant sur les entites geographiques
29 
 *
54 david 30 
 *
199 david 31 
 * @author aurelien + david
54 david 32 
 *
33 
 */
199 david 34 
 
35 
 
68 david 36 
public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,
54 david 37 
		Filtrable {
38 
 
39 
	/**
40 
	 * Le médiateur associé à la vue
41 
	 */
42 
	private ObservationMediateur	observationMediateur		= null;
43 
 
44 
	/**
45 
	 * Les localites en cours
46 
	 */
68 david 47 
	private String entitesGeographiquesEncours = "";
54 david 48 
 
49 
	/**
50 
	 * Le treepanel qui affiche l'arbre
51 
	 */
68 david 52 
	private TreePanel arbreEntitesGeographiques = null;
54 david 53 
 
68 david 54 
 
54 david 55 
	/**
56 
	 * booléen d'initialisation
57 
	 */
58 
	private boolean estInstancie = false;
59 
 
60 
	/**
61 
	 * booléen d'etat
62 
	 */
63 
	private boolean filtreModifie = false;
85 jpm 64 
	private boolean arbreCharge = false ;
65 
 
86 jpm 66 
	private String nomFiltre = "" ;
67 
 
54 david 68 
	/**
69 
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
70 
	 */
71 
	@SuppressWarnings("unused")
68 david 72 
	private ArbreEntiteGeographiqueObservationFiltreVue() {
54 david 73 
		super();
74 
	}
75 
 
76 
	/**
77 
	 * Constructeur avec paramètres
78 
	 *
79 
	 * @param im
80 
	 *            le médiateur à associer
81 
	 */
68 david 82 
	public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {
54 david 83 
 
84 
		// on crée le panel
2622 mathias 85 
		super(Msg.get("localites"));
54 david 86 
 
87 
		this.observationMediateur = obs;
88 
 
68 david 89 
		arbreEntitesGeographiques = new TreePanel();
54 david 90 
 
91 
		this.setPaddings(5);
92 
 
93 
		this.setCollapsible(true);
202 david 94 
 
95 
		this.setAutoScroll(true);
128 aurelien 96 
 
54 david 97 
 
98 
		// on ajoute les listeners
99 
		ajouterListenersPanel();
100 
		estInstancie = false;
101 
	}
102 
 
103 
	/**
104 
	 * Ajoute les listeners pour le rendu du panel
105 
	 */
106 
	private void ajouterListenersPanel() {
68 david 107 
		  this.addListener(new PanelListenerAdapter() {
54 david 108 
 
109 
			// on instancie réellement les composants au moment du rendu pour
110 
			// accélérer l'affichage
111 
			// et éviter des bugs
1292 aurelien 112 
			@Override
54 david 113 
			public void onRender(Component component) {
114 
 
115 
				// on interdit le drag and drop dans l'arbre
68 david 116 
				arbreEntitesGeographiques.setEnableDD(false);
73 david 117 
				arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
54 david 118 
 
119 
				// on crée une racine pour l'arbre
2622 mathias 120 
				TreeNode root = new TreeNode(Msg.get("localites"));
70 david 121 
				root.setId("racine_entite");
2622 mathias 122 
				String[] usObject = { Msg.get("localites") };
54 david 123 
				root.setUserObject(usObject);
124 
 
68 david 125 
				arbreEntitesGeographiques.setRootNode(root);
126 
				arbreEntitesGeographiques.setRootVisible(true);
127 
				arbreEntitesGeographiques.setBorder(false);
85 jpm 128 
				root.setExpandable(true) ;
54 david 129 
 
68 david 130 
				add(arbreEntitesGeographiques);
54 david 131 
 
132 
				// on ajoute les listeners d'évenements
133 
				ajouterListeners();
134 
 
135 
 
136 
				// enfin on considère le composant comme instancié
137 
				estInstancie = true;
138 
			}
139 
		});
140 
	}
68 david 141 
 
54 david 142 
	/**
70 david 143 
	 * ajoute les listeners pour les boutons et le cochage des entites
54 david 144 
	 */
145 
	private void ajouterListeners() {
85 jpm 146 
 
147 
		arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() {
148 
 
1292 aurelien 149 
			@Override
85 jpm 150 
			public void onClick(TreeNode node, EventObject e) {
683 aurelien 151 
				gererClicNoeud(node);
85 jpm 152 
			}
153 
 
154 
		}) ;
87 jpm 155 
 
156 
		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
157 
 
1292 aurelien 158 
			@Override
87 jpm 159 
			public void onExpand(Node node) {
160 
				if(!arbreCharge)
161 
				{
162 
					observationMediateur.obtenirListeEntiteGeographique() ;
163 
					arbreCharge = true ;
164 
				}
165 
			}
166 
 
167 
		}) ;
54 david 168 
	}
140 aurelien 169 
 
683 aurelien 170 
	private void gererClicNoeud(TreeNode node) {
171 
 
172 
		mettreAJourValeurEnCours(node);
173 
		observationMediateur.obtenirNombreObservation() ;
174 
	}
175 
 
176 
	private void mettreAJourValeurEnCours(TreeNode node) {
177 
 
178 
		nomFiltre = "" ;
179 
		entitesGeographiquesEncours = "" ;
180 
 
2568 aurelien 181 
		String[] filtresStr = {"pays","departement","localite","lieudit","station"};
182 
 
183 
		int profNoeud = node.getDepth();
184 
		if(profNoeud == 0) {
683 aurelien 185 
				if(!arbreCharge)
186 
				{
187 
					arbreEntitesGeographiques.getRootNode().expand();
188 
				}
189 
				else
190 
				{
191 
					observationMediateur.obtenirNombreObservation() ;
192 
				}
2568 aurelien 193 
		} else {
194 
			Node noeud = (Node)node;
195 
			for(int i = profNoeud - 1; i >= 0; i--) {
196 
				nomFiltre += filtresStr[i]+",";
197 
				entitesGeographiquesEncours += ((String[])noeud.getUserObject())[0]+",";
198 
				noeud = noeud.getParentNode();
199 
			}
200 
			nomFiltre.replaceAll(",$", "");
201 
			entitesGeographiquesEncours.replaceAll(",$", "");
683 aurelien 202 
		}
203 
 
204 
		filtreModifie = true ;
205 
	}
206 
 
140 aurelien 207 
	public void initialiser() {
208 
 
209 
		arbreCharge = false ;
263 aurelien 210 
		entitesGeographiquesEncours = "";
140 aurelien 211 
		arbreEntitesGeographiques.collapseAll();
212 
		// on vide l'ancien arbre
213 
		Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes();
214 
		for (int i = 0; i < rootChild.length; i++) {
215 
 
216 
			rootChild[i].remove();
217 
		}
218 
 
219 
		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
220 
 
1292 aurelien 221 
			@Override
140 aurelien 222 
			public void onExpand(Node node) {
223 
				if(!arbreCharge)
224 
				{
225 
					observationMediateur.obtenirListeEntiteGeographique() ;
226 
					arbreCharge = true ;
227 
				}
228 
			}
229 
 
230 
		}) ;
231 
	}
54 david 232 
 
233 
	/**
234 
	 * Méthode héritée de l'interface rafraichissable
235 
	 */
1292 aurelien 236 
	@Override
54 david 237 
	public void rafraichir(Object nouvelleDonnees,
238 
			boolean repandreRaffraichissement) {
239 
 
128 aurelien 240 
 
68 david 241 
		if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
242 
 
243 
			ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
244 
 
245 
				// on crée un arbre vide
166 aurelien 246 
				Tree nouvelArbre = new Tree() ;
68 david 247 
				TreeNode root = new TreeNode();
72 david 248 
				root.setId("racine_entite");
2622 mathias 249 
				root.setText(Msg.get("localites"));
250 
				String[] usObjRoot = { Msg.get("localites") };
89 jpm 251 
				root.setUserObject(usObjRoot);
166 aurelien 252 
				nouvelArbre.setRootNode(root);
68 david 253 
 
89 jpm 254 
				// on vide tous les noeuds
255 
				arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {
256 
 
1292 aurelien 257 
					@Override
89 jpm 258 
					public boolean execute(Node node) {
259 
						node.remove();
260 
						return true;
261 
					}
262 
				});
263 aurelien 263 
 
264 
			// on la parse et on récupère les informations qui nous interessent
265 
			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
199 david 266 
 
1292 aurelien 267 
					EntiteGeographiqueObservation ent=data.get(it.next());
263 aurelien 268 
					creerHierarchieNoeud(nouvelArbre ,root, ent);
269 
					doLayout();
270 
				}
271 
 
166 aurelien 272 
				copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode());
263 aurelien 273 
				arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ;
54 david 274 
 
89 jpm 275 
				// si l'arbre n'était pas encore considéré comme instancié
199 david 276 
 
89 jpm 277 
				if (!estInstancie) {
278 
					// on signale que oui
279 
					estInstancie = true;
54 david 280 
				}
89 jpm 281 
 
282 
				// l'état du filtre est réinitialisé
283 
				filtreModifie = false;
109 aurelien 284 
 
89 jpm 285 
				//show() ;
166 aurelien 286 
				arbreEntitesGeographiques.doLayout();
54 david 287 
 
288 
			}
2622 mathias 289 
 
89 jpm 290 
		if(nouvelleDonnees instanceof Observation)
128 aurelien 291 
		{
199 david 292 
			// Cas d'ajout unitaire d'une observation
293 
 
128 aurelien 294 
			// si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout
295 
			// l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement
296 
			// de l'arbre
297 
			if(!arbreCharge) {
298 
				return;
299 
			}
2622 mathias 300 
 
89 jpm 301 
			Observation obs = (Observation)nouvelleDonnees ;
263 aurelien 302 
			EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation());
2568 aurelien 303 
			ent.setPays(obs.getPays());
2622 mathias 304 
 
263 aurelien 305 
			creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent);
2622 mathias 306 
 
307 
			doLayout();
263 aurelien 308 
			arbreEntitesGeographiques.doLayout() ;
89 jpm 309 
		}
68 david 310 
	}
54 david 311 
 
312 
 
313 
	/**
314 
	 * Accesseur pour le panneau contenant l'arbre
315 
	 *
316 
	 * @return le panneau de l'arbre des mots clés
317 
	 */
318 
	public TreePanel getArbreMotsCles() {
68 david 319 
		return arbreEntitesGeographiques;
54 david 320 
	}
321 
 
322 
	/**
323 
	 * Méthode héritée de Filtrable renvoie le nom du filtre
324 
	 */
1292 aurelien 325 
	@Override
54 david 326 
	public String renvoyerNomFiltre() {
327 
 
2622 mathias 328 
		return Msg.get("localites");
54 david 329 
	}
330 
 
331 
	/**
332 
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
333 
	 *
334 
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
335 
	 */
1292 aurelien 336 
	@Override
54 david 337 
	public String[] renvoyerValeursAFiltrer() {
338 
 
339 
		valider();
85 jpm 340 
 
86 jpm 341 
		String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ;
54 david 342 
 
343 
		return valeursFiltrees;
344 
	}
345 
 
346 
	/**
347 
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
348 
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
349 
	 *
350 
	 * @param ndPereOriginal
351 
	 *            le père des noeuds de l'arbre original
352 
	 * @param ndPereCopie
353 
	 *            le père qui va recevoir les copies
354 
	 */
355 
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
356 
		if (ndPereCopie != null && ndPereOriginal != null) {
357 
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
358 
 
359 
			for (int i = 0; i < ndNodeFils.length; i++) {
360 
 
361 
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
362 
				TreeNode child = new TreeNode(usObj[0]);
363 
				child.setUserObject(usObj);
166 aurelien 364 
				child.setId(""+usObj[1]);
54 david 365 
				ndPereCopie.appendChild(child);
366 
 
367 
				if (!ndNodeFils[i].isLeaf()) {
368 
					copierFilsNoeud(ndNodeFils[i], child);
369 
				}
370 
 
371 
			}
372 
		}
373 
	}
374 
 
375 
	/**
376 
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
377 
	 */
1292 aurelien 378 
	@Override
54 david 379 
	public boolean renvoyerEtatFiltre() {
380 
 
381 
		return filtreModifie;
382 
	}
383 
 
1292 aurelien 384 
	@Override
54 david 385 
	public void valider() {
86 jpm 386 
 
54 david 387 
		if (estInstancie) {
86 jpm 388 
 
54 david 389 
		}
390 
	}
2622 mathias 391 
 
90 jpm 392 
	public Comparator<TreeNode> comparerNoeuds()
393 
	{
394 
		return new Comparator<TreeNode>() {
54 david 395 
 
1292 aurelien 396 
			@Override
90 jpm 397 
			public int compare(TreeNode o1, TreeNode o2) {
398 
 
2624 aurelien 399 
				if(o1.getText().equals(Msg.get("inconnue"))) {
109 aurelien 400 
					return -1 ;
401 
				}
402 
 
2624 aurelien 403 
				if(o2.getText().equals(Msg.get("inconnue"))) {
109 aurelien 404 
					return 1 ;
405 
				}
406 
 
407 
				if(o1.getDepth() == 1 && o2.getDepth() == 1)
91 jpm 408 
				{
109 aurelien 409 
					String l1 = o1.getText() ;
410 
					String l2 = o2.getText() ;
411 
					if(l1.length() == 1) {
412 
						l1 = "0"+l1;
413 
					}
91 jpm 414 
 
109 aurelien 415 
					if(l2.length() == 1) {
416 
						l2 = "0"+l2;
417 
					}
418 
 
128 aurelien 419 
					Integer n1 = 0;
420 
					Integer n2 = 0;
109 aurelien 421 
 
128 aurelien 422 
					try{
423 
						n1 = Integer.parseInt(l1) ;
424 
						n2 = Integer.parseInt(l2) ;
425 
					} catch(NumberFormatException ne)  {
426 
						n1 = 0;
427 
						n2 = 0;
428 
					}
429 
 
91 jpm 430 
					return n1.compareTo(n2) ;
431 
				}
432 
				else
263 aurelien 433 
				{
434 
					String n1 = o1.getId() ;
435 
					String n2 = o2.getId() ;
436 
 
90 jpm 437 
 
263 aurelien 438 
					return  n1.compareToIgnoreCase(n2);
91 jpm 439 
				}
90 jpm 440 
			}
441 
		} ;
442 
	}
104 jpm 443 
 
444 
	public void raz() {
263 aurelien 445 
 
104 jpm 446 
		arbreCharge = false ;
140 aurelien 447 
		arbreEntitesGeographiques.collapseAll();
104 jpm 448 
		arbreEntitesGeographiques.clear() ;
449 
 
450 
		// on crée une racine pour l'arbre
2622 mathias 451 
		TreeNode root = new TreeNode(Msg.get("localites"));
104 jpm 452 
		root.setId("racine_entite");
2622 mathias 453 
		String[] usObject = { Msg.get("localites") };
104 jpm 454 
		root.setUserObject(usObject);
455 
 
456 
		arbreEntitesGeographiques.setRootNode(root);
457 
 
458 
		arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() {
459 
 
1292 aurelien 460 
			@Override
104 jpm 461 
			public void onExpand(Node node) {
462 
				if(!arbreCharge)
463 
				{
464 
					observationMediateur.obtenirDatesObservation() ;
465 
					arbreCharge = true ;
466 
				}
467 
			}
468 
 
469 
		}) ;
470 
 
263 aurelien 471 
		entitesGeographiquesEncours  = "";
104 jpm 472 
 
263 aurelien 473 
	}
474 
 
475 
	private TreeNode creerNoeud(String id, String texte) {
104 jpm 476 
 
263 aurelien 477 
		TreeNode nouveauNoeud = new TreeNode();
478 
		nouveauNoeud.setId(""+(id));
479 
		nouveauNoeud.setText(texte);
480 
		String[] usObj = {texte,id+""};
481 
		nouveauNoeud.setUserObject(usObj);
482 
 
483 
		return nouveauNoeud;
104 jpm 484 
	}
91 jpm 485 
 
263 aurelien 486 
	/**
487 
	 *
488 
	 * @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds
489 
	 * @param root le noeud racine auquel on concatène la hierarchie crée
490 
	 * @param ent l'entité géographique qui doit être décomposée en arborescence
491 
	 * @return
492 
	 */
493 
	private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) {
494 
 
965 aurelien 495 
		String id_zone_geo=null;
496 
		String zone_geo=null;
263 aurelien 497 
		String lieuDit=null;
498 
		String station=null;
499 
 
2568 aurelien 500 
		String id_pays = ent.getPays();
501 
 
965 aurelien 502 
		// TODO creer une fonction plus efficace lors du passage au multi reférentiel
503 
		id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo());
263 aurelien 504 
 
965 aurelien 505 
		id_zone_geo = id_zone_geo.replaceAll("\"", "");
506 
		id_zone_geo = id_zone_geo.replace('\\',' ');
507 
		id_zone_geo = id_zone_geo.trim();
508 
		zone_geo = ent.getZoneGeo();
509 
		lieuDit = ent.getLieuDit();
510 
		station = ent.getStation();
263 aurelien 511 
 
2568 aurelien 512 
		if(id_pays.equals(null) || (id_pays.trim()).isEmpty()) {
2624 aurelien 513 
			id_pays=Msg.get("inconnue") ;
2568 aurelien 514 
		}
515 
 
965 aurelien 516 
		if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) {
2624 aurelien 517 
			id_zone_geo=Msg.get("inconnue") ;
2568 aurelien 518 
		} else {
519 
			if(ent.getIdZoneGeo().contains("INSEE-C:") && ent.getIdZoneGeo().length() > 10) {
520 
				id_pays = "FR";
521 
			}
263 aurelien 522 
		}
523 
 
965 aurelien 524 
		if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) {
2624 aurelien 525 
			zone_geo=Msg.get("inconnue") ;
263 aurelien 526 
		}
527 
 
528 
		if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) {
2624 aurelien 529 
			lieuDit=Msg.get("inconnue") ;
263 aurelien 530 
		}
531 
 
532 
		if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) {
2624 aurelien 533 
			station=Msg.get("inconnue") ;
263 aurelien 534 
		}
535 
 
2568 aurelien 536 
		String[] idLocalites = {id_pays, id_zone_geo, zone_geo, lieuDit, station};
263 aurelien 537 
 
2568 aurelien 538 
		Node noeudMemeId = null;
539 
		String idNoeud = "";
540 
		String locNiveau = "";
2622 mathias 541 
 
2568 aurelien 542 
		Node noeudParent = root;
2622 mathias 543 
 
2568 aurelien 544 
		for(int i = 0; i < idLocalites.length; i++) {
545 
			// Recherche des noeuds correspondant à chacun des niveaux de la hierarchie
546 
			locNiveau = idLocalites[i];
547 
			idNoeud += idLocalites[i];
2622 mathias 548 
 
2568 aurelien 549 
			noeudMemeId = arbre.getNodeById(idNoeud);
2622 mathias 550 
 
2568 aurelien 551 
			// Si le noeud n'existe pas on le crée
552 
			if(noeudMemeId == null) {
553 
				noeudMemeId = creerNoeud(idNoeud, locNiveau);
554 
				noeudParent.appendChild(noeudMemeId) ;
555 
			}
2622 mathias 556 
 
2568 aurelien 557 
			noeudParent = noeudMemeId;
263 aurelien 558 
		}
2622 mathias 559 
 
263 aurelien 560 
		root.sort(comparerNoeuds()) ;
561 
	}
683 aurelien 562 
 
563 
	@Override
564 
	public void viderFiltre() {
565 
		arbreEntitesGeographiques.getSelectionModel().clearSelections();
566 
		entitesGeographiquesEncours ="";
567 
	}
568 
 
569 
	public void viderFiltre(String nom) {
570 
 
571 
		final int profondeur = calculerProfondeurPourNomFiltre(nom);
572 
 
573 
		// on vide tous les noeuds
574 
		arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() {
575 
 
1292 aurelien 576 
			@Override
683 aurelien 577 
			public boolean execute(Node node) {
578 
 
579 
				boolean continuer = true;
580 
 
581 
				TreeNode noeudArbreEncours = (TreeNode)node;
582 
 
583 
				if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) {
584 
 
585 
					int profondeurDepart = noeudArbreEncours.getDepth();
586 
 
587 
					for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {
588 
						noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();
589 
					}
590 
 
591 
					arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours);
592 
					mettreAJourValeurEnCours(noeudArbreEncours);
2622 mathias 593 
 
683 aurelien 594 
					continuer = false;
595 
				}
2622 mathias 596 
 
683 aurelien 597 
				return continuer;
598 
			}
599 
 
600 
		});
601 
	}
2622 mathias 602 
 
683 aurelien 603 
	private int calculerProfondeurPourNomFiltre(String nom) {
2622 mathias 604 
 
683 aurelien 605 
		int profondeur = 0;
2622 mathias 606 
 
2568 aurelien 607 
		if(nom.equals("pays")) {
683 aurelien 608 
			profondeur = 1;
609 
		}
2622 mathias 610 
 
2568 aurelien 611 
		if(nom.equals("departement")) {
683 aurelien 612 
			profondeur = 2;
613 
		}
2622 mathias 614 
 
2568 aurelien 615 
		if(nom.equals("localite")) {
683 aurelien 616 
			profondeur = 3;
617 
		}
2622 mathias 618 
 
2568 aurelien 619 
		if(nom.equals("lieudit")) {
683 aurelien 620 
			profondeur = 4;
621 
		}
2622 mathias 622 
 
2568 aurelien 623 
		if(nom.equals("station")) {
624 
			profondeur = 5;
625 
		}
2622 mathias 626 
 
683 aurelien 627 
		return profondeur;
628 
	}
2622 mathias 629 
 
54 david 630 
}