Subversion Repositories eFlore/Applications.cel

Rev

Rev 2624 | 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
 
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
}