Subversion Repositories eFlore/Applications.cel

Rev

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