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
}