Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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