Subversion Repositories eFlore/Applications.cel

Rev

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