Subversion Repositories eFlore/Applications.cel

Rev

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