Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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