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