Subversion Repositories eFlore/Applications.cel

Rev

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