Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
91 jpm 1
package org.tela_botanica.client.vues;
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;
9
import org.tela_botanica.client.modeles.EntiteGeographiqueObservation;
10
import org.tela_botanica.client.modeles.ListeDateObservation;
11
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;
12
import org.tela_botanica.client.modeles.ListeObservation;
13
import org.tela_botanica.client.modeles.Observation;
14
import org.tela_botanica.client.observation.ObservationMediateur;
15
 
16
import com.google.gwt.core.client.GWT;
17
import com.google.gwt.json.client.JSONArray;
18
import com.google.gwt.json.client.JSONObject;
19
import com.google.gwt.user.client.Window;
20
import com.google.gwt.user.client.ui.Label;
21
import com.gwtext.client.data.Node;
22
import com.gwtext.client.data.NodeTraversalCallback;
23
import com.gwtext.client.data.Tree;
24
import com.gwtext.client.data.event.NodeListenerAdapter;
25
import com.gwtext.client.widgets.Component;
26
import com.gwtext.client.widgets.Panel;
27
import com.gwtext.client.widgets.event.PanelListenerAdapter;
28
import com.gwtext.client.widgets.tree.TreeNode;
29
import com.gwtext.client.widgets.tree.TreePanel;
30
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
31
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
32
import com.gwtext.client.core.EventObject;
33
 
34
/**
35
 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
36
 * cliquable
37
 *
38
 * @author aurelien
39
 *
40
 */
41
public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,
42
		Filtrable {
43
 
44
	/**
45
	 * Le médiateur associé à la vue
46
	 */
47
	private ObservationMediateur	observationMediateur		= null;
48
 
49
	/**
50
	 * Les localites en cours
51
	 */
52
	private String donneesDateEnCours = "";
53
 
54
	/**
55
	 * Le treepanel qui affiche l'arbre
56
	 */
57
	private TreePanel arbreDonneesDates = null;
58
 
59
 
60
 
61
	/**
62
	 * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
63
	 */
64
 
65
	private Tree donneesDates = new Tree();
66
 
67
	/**
68
	 * booléen d'initialisation
69
	 */
70
	private boolean estInstancie = false;
71
 
72
	/**
73
	 * booléen d'etat
74
	 */
75
	private boolean filtreModifie = false;
76
 
77
	private boolean arbreCharge = false ;
78
 
79
	private String nomFiltre = "" ;
80
 
81
	/**
82
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
83
	 */
84
	@SuppressWarnings("unused")
85
	private ArbreDateObservationFiltreVue() {
86
		super();
87
	}
88
 
89
	/**
90
	 * Constructeur avec paramètres
91
	 *
92
	 * @param im
93
	 *            le médiateur à associer
94
	 */
95
	public ArbreDateObservationFiltreVue(ObservationMediateur obs) {
96
 
97
		// on crée le panel
98
		super("Dates");
99
 
100
		this.observationMediateur = obs;
101
 
102
		arbreDonneesDates = new TreePanel();
103
 
104
		this.setPaddings(5);
105
 
106
		this.setCollapsible(true);
107
		this.setAutoWidth(true);
99 jpm 108
 
109
		if (GWT.isScript()) {
110
			setAutoScroll(true);
111
		}
91 jpm 112
 
113
		// on ajoute les listeners
114
		ajouterListenersPanel();
115
		estInstancie = false;
116
	}
117
 
118
	/**
119
	 * Ajoute les listeners pour le rendu du panel
120
	 */
121
	private void ajouterListenersPanel() {
122
		  this.addListener(new PanelListenerAdapter() {
123
 
124
			// on instancie réellement les composants au moment du rendu pour
125
			// accélérer l'affichage
126
			// et éviter des bugs
127
			public void onRender(Component component) {
128
 
129
				// on interdit le drag and drop dans l'arbre
130
				arbreDonneesDates.setEnableDD(false);
131
				arbreDonneesDates.setId("x-view-tree-filter-date");
132
				arbreDonneesDates.setAutoWidth(false);
133
 
134
				arbreDonneesDates.setBorder(false);
135
 
136
				// on crée une racine pour l'arbre
137
				TreeNode root = new TreeNode("Dates");
138
				root.setId("racine_date");
139
				String[] usObject = { "Dates" };
140
				root.setUserObject(usObject);
141
 
142
				arbreDonneesDates.setRootNode(root);
143
				arbreDonneesDates.setRootVisible(true);
144
				arbreDonneesDates.setBorder(false);
145
				root.setExpandable(true) ;
146
 
147
				add(arbreDonneesDates);
148
 
149
				// on ajoute les listeners d'évenements
150
				ajouterListeners();
151
 
152
 
153
				// enfin on considère le composant comme instancié
154
				estInstancie = true;
155
 
156
 
157
			}
158
 
159
		});
160
	}
161
 
162
 
163
 
164
	/**
165
	 * ajoute les listeners pour les boutons et le cochage des entites
166
	 */
167
	private void ajouterListeners() {
168
 
169
		arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
170
 
171
			public void onClick(TreeNode node, EventObject e) {
172
 
173
				nomFiltre = "" ;
174
				donneesDateEnCours = "" ;
175
				String nomPere = "" ;
176
				String nomGrandPere = "" ;
177
 
178
				switch(node.getDepth())
179
				{
180
					case 0:
181
						if(!arbreCharge)
182
						{
183
							arbreCharge = true ;
184
							observationMediateur.obtenirDatesObservation() ;
185
						}
186
						else
187
						{
188
							observationMediateur.obtenirNombreObservation() ;
189
						}
190
						return ;
191
					case 3: nomFiltre += "annee,mois,jour";
94 jpm 192
						nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
193
						nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
194
						donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
91 jpm 195
						break;
196
					case 2: nomFiltre += "annee,mois";
94 jpm 197
						nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
198
						donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
91 jpm 199
						break;
200
					case 1: nomFiltre += "annee";
94 jpm 201
						donneesDateEnCours += ((String[])node.getUserObject())[1] ;
91 jpm 202
						break;
203
					default:
204
						break;
205
				}
206
 
207
				filtreModifie = true ;
208
				observationMediateur.obtenirNombreObservation() ;
209
 
210
			}
211
 
212
		}) ;
213
 
214
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
215
 
216
			public void onExpand(Node node) {
217
				if(!arbreCharge)
218
				{
219
					observationMediateur.obtenirDatesObservation() ;
220
					arbreCharge = true ;
221
				}
222
			}
223
 
224
		}) ;
225
	}
226
 
227
	/**
228
	 * Méthode héritée de l'interface rafraichissable
229
	 */
230
	public void rafraichir(Object nouvelleDonnees,
231
			boolean repandreRaffraichissement) {
232
 
233
		if (nouvelleDonnees instanceof ListeDateObservation) {
234
 
235
			String annee=null;
236
			String mois=null;
237
			String jour=null;
238
 
239
			ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ;
240
 
241
				// on crée un arbre vide
242
				TreeNode root = new TreeNode();
243
				root.setId("racine_date");
244
				root.setText("Dates");
94 jpm 245
				String[] usObjRoot = { "Dates", "Dates"};
91 jpm 246
				root.setUserObject(usObjRoot);
247
				donneesDates.setRootNode(root);
248
 
249
			// on la parse et on récupère les informations qui nous interessent
250
			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
251
 
252
				DateObservation ent=(DateObservation) data.get(it.next());
253
 
254
				annee= ent.getAnnee() ;
255
				mois= ent.getMois() ;
256
				String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
257
				jour= ent.getJour() ;
258
 
259
				if(annee.contains("0000")) {
260
					annee="Inconnue" ;
261
				}
262
 
263
				if(jour.contains("00")) {
264
					jour="Inconnue" ;
265
				}
266
 
94 jpm 267
				Node noeudMemeAnnee = donneesDates.getNodeById(""+annee);
91 jpm 268
				// si la région existe déjà
94 jpm 269
					if(noeudMemeAnnee != null)
91 jpm 270
					{
271
						// on teste si la localité existe
94 jpm 272
						Node noeudMemeMois = donneesDates.getNodeById(""+(annee+mois));
273
						if(noeudMemeMois != null)
91 jpm 274
						{
275
							// enfin on teste si le lieu dit existe
94 jpm 276
							Node noeudMemeJour = donneesDates.getNodeById(""+(annee+mois+jour));
277
							if(noeudMemeJour != null)
91 jpm 278
							{
279
								// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
280
							}
281
							else
282
							{
283
								// enfin on ne crée que le noeud du lieu dit
94 jpm 284
								TreeNode node_jour = new TreeNode();
285
								node_jour.setId(""+(annee+mois+jour));
286
								node_jour.setText(jour);
287
								noeudMemeMois.appendChild(node_jour) ;
288
								String[] usObj = {jour,jour};
289
								node_jour.setUserObject(usObj);
91 jpm 290
							}
291
						}
292
						else
293
						{
94 jpm 294
							TreeNode node_mois = new TreeNode();
295
							node_mois.setId(""+(annee+mois));
296
							node_mois.setText(moisLettre);
297
							noeudMemeAnnee.appendChild(node_mois) ;
298
							String[] usObj = {moisLettre,mois};
299
							node_mois.setUserObject(usObj);
91 jpm 300
 
94 jpm 301
							TreeNode node_jour = new TreeNode();
302
							node_jour.setId(""+(annee+mois+jour));
303
							node_jour.setText(jour);
304
							node_mois.appendChild(node_jour) ;
305
							String[] usObj2 = {jour,jour};
306
							node_jour.setUserObject(usObj2);
91 jpm 307
 
308
						}
309
					}
310
					else
311
					{
94 jpm 312
						TreeNode node_annee = new TreeNode();
313
						node_annee.setId(""+annee);
314
						node_annee.setText(annee);
315
						root.appendChild(node_annee) ;
316
						String[] usObj = {annee, annee};
317
						node_annee.setUserObject(usObj);
91 jpm 318
 
94 jpm 319
						TreeNode node_mois = new TreeNode();
320
						node_mois.setId(""+(annee+mois));
321
						node_mois.setText(moisLettre);
322
						node_annee.appendChild(node_mois) ;
323
						String[] usObj2 = {moisLettre,mois};
324
						node_mois.setUserObject(usObj2);
91 jpm 325
 
94 jpm 326
						TreeNode node_jour = new TreeNode();
327
						node_jour.setId(""+(annee+mois+jour));
328
						node_jour.setText(jour);
329
						node_mois.appendChild(node_jour) ;
330
						String[] usObj3 = {jour,jour};
331
						node_jour.setUserObject(usObj3);
91 jpm 332
					}
333
 
334
				}
335
 
336
				// on vide tous les noeuds
337
				arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
338
 
339
					public boolean execute(Node node) {
340
 
341
						node.remove();
342
						return true;
343
					}
344
 
345
				});
346
 
347
				// et on recopie le nouvel arbre
348
				copierFilsNoeud(donneesDates.getRootNode(), arbreDonneesDates
349
						.getRootNode());
350
 
94 jpm 351
				// on trie
352
				root.sort(comparerNoeuds()) ;
353
 
91 jpm 354
				// si l'arbre n'était pas encore considéré comme instancié
355
				if (!estInstancie) {
356
					// on signale que oui
357
					estInstancie = true;
358
				}
359
 
360
				// l'état du filtre est réinitialisé
361
				filtreModifie = false;
362
				//show() ;
363
				doLayout();
364
 
365
			}
366
 
94 jpm 367
		if(nouvelleDonnees instanceof Observation)
91 jpm 368
		{
94 jpm 369
			Observation ent = (Observation)nouvelleDonnees ;
370
			String dateSpl[] = ent.getDate().split("/") ;
91 jpm 371
 
94 jpm 372
			String annee= dateSpl[2];
373
			String mois= dateSpl[1];
374
			String jour= dateSpl[0];
375
 
91 jpm 376
			String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
377
 
378
			Node root = arbreDonneesDates.getRootNode() ;
379
 
380
			if(annee.contains("0000") || annee.equals(null)) {
381
				annee="Inconnue" ;
382
			}
383
 
384
			if(jour.contains("00") || jour.equals(null)) {
385
				jour="Inconnue" ;
386
			}
387
 
94 jpm 388
			Node noeudMemeAnnee = donneesDates.getNodeById(""+annee);
91 jpm 389
			// si la région existe déjà
94 jpm 390
				if(noeudMemeAnnee != null)
391
				{
91 jpm 392
					// on teste si la localité existe
94 jpm 393
					Node noeudMemeMois = donneesDates.getNodeById(""+(annee+mois));
394
					if(noeudMemeMois != null)
91 jpm 395
					{
396
						// enfin on teste si le lieu dit existe
94 jpm 397
						Node noeudMemeJour = donneesDates.getNodeById(""+(annee+mois+jour));
398
						if(noeudMemeJour != null)
91 jpm 399
						{
400
							// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
401
						}
402
						else
403
						{
404
							// enfin on ne crée que le noeud du lieu dit
94 jpm 405
							TreeNode node_jour = new TreeNode();
406
							node_jour.setId(""+(annee+mois+jour));
407
							node_jour.setText(jour);
408
							String[] usObj = {jour,jour};
409
							node_jour.setUserObject(usObj);
410
							noeudMemeMois.appendChild(node_jour) ;
411
 
412
							root.sort(comparerNoeuds()) ;
91 jpm 413
						}
414
					}
415
					else
416
					{
94 jpm 417
						TreeNode node_mois = new TreeNode();
418
						node_mois.setId(""+(annee+mois));
419
						node_mois.setText(moisLettre);
420
						String[] usObj = {moisLettre,mois};
421
						node_mois.setUserObject(usObj);
422
						noeudMemeAnnee.appendChild(node_mois) ;
91 jpm 423
 
94 jpm 424
						Window.alert("on crée on nouveau mois "+node_mois.getId()) ;
91 jpm 425
 
94 jpm 426
						TreeNode node_jour = new TreeNode();
427
						node_jour.setId(""+(annee+mois+jour));
428
						node_jour.setText(jour);
429
						String[] usObj2 = {jour,jour};
430
						node_jour.setUserObject(usObj2);
431
						node_mois.appendChild(node_jour) ;
432
 
433
						root.sort(comparerNoeuds()) ;
91 jpm 434
					}
435
			}
436
			else
437
			{
438
 
94 jpm 439
				TreeNode node_annee = new TreeNode();
440
				node_annee.setId(""+annee);
441
				node_annee.setText(annee);
442
				String[] usObj = {annee,annee};
443
				node_annee.setUserObject(usObj);
444
				root.appendChild(node_annee) ;
91 jpm 445
 
94 jpm 446
				TreeNode node_mois = new TreeNode();
447
				node_mois.setId(""+(annee+mois));
448
				node_mois.setText(moisLettre);
449
				String[] usObj2 = {moisLettre,mois};
450
				node_mois.setUserObject(usObj2);
451
				node_annee.appendChild(node_mois) ;
91 jpm 452
 
94 jpm 453
				TreeNode node_jour = new TreeNode();
454
				node_jour.setId(""+(annee+mois+jour));
455
				node_jour.setText(jour);
456
				String[] usObj3 = {jour,jour};
457
				node_jour.setUserObject(usObj3);
458
				node_mois.appendChild(node_jour) ;
91 jpm 459
 
460
				// TODO : améliorer la compararaison des noeuds
461
				root.sort(comparerNoeuds()) ;
462
			}
463
 
464
				arbreDonneesDates.doLayout() ;
465
		}
466
	}
467
 
468
 
469
	/**
470
	 * Accesseur pour le panneau contenant l'arbre
471
	 *
472
	 * @return le panneau de l'arbre des mots clés
473
	 */
474
	public TreePanel getArbreMotsCles() {
475
		return arbreDonneesDates;
476
	}
477
 
478
	/**
479
	 * Méthode héritée de Filtrable renvoie le nom du filtre
480
	 */
481
	public String renvoyerNomFiltre() {
482
 
483
		return "Dates";
484
	}
485
 
486
	/**
487
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
488
	 *
489
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
490
	 */
491
	public String[] renvoyerValeursAFiltrer() {
492
 
493
		valider();
494
 
495
		String valeursFiltrees[] = {nomFiltre, donneesDateEnCours } ;
496
 
497
		return valeursFiltrees;
498
	}
499
 
500
	/**
501
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
502
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
503
	 *
504
	 * @param ndPereOriginal
505
	 *            le père des noeuds de l'arbre original
506
	 * @param ndPereCopie
507
	 *            le père qui va recevoir les copies
508
	 */
509
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
510
		if (ndPereCopie != null && ndPereOriginal != null) {
511
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
512
 
513
			for (int i = 0; i < ndNodeFils.length; i++) {
514
 
515
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
516
				TreeNode child = new TreeNode(usObj[0]);
517
				child.setUserObject(usObj);
518
				ndPereCopie.appendChild(child);
519
 
520
				if (!ndNodeFils[i].isLeaf()) {
521
					copierFilsNoeud(ndNodeFils[i], child);
522
				}
523
 
524
			}
525
		}
526
	}
527
 
528
	/**
529
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
530
	 */
531
	public boolean renvoyerEtatFiltre() {
532
 
533
		return filtreModifie;
534
	}
535
 
536
	public void valider() {
537
 
538
		if (estInstancie) {
539
 
540
		}
541
	}
542
 
543
	public Comparator<TreeNode> comparerNoeuds()
544
	{
545
		return new Comparator<TreeNode>() {
546
 
547
			public int compare(TreeNode o1, TreeNode o2) {
548
 
94 jpm 549
				String n1 = ((String[])o1.getUserObject())[1] ;
550
				String n2 = ((String[])o2.getUserObject())[1] ;
91 jpm 551
 
552
				return n1.compareTo(n2) ;
553
			}
554
 
555
		} ;
556
	}
557
 
558
	public String renvoyerMois(int numMois) {
559
 
560
		switch (numMois) {
561
		case 1:
562
			return "janvier" ;
563
		case 2:
564
			return "fevrier" ;
565
		case 3:
566
			return "mars" ;
567
		case 4:
568
			return "avril" ;
569
		case 5:
570
			return "mai" ;
571
		case 6:
572
			return "juin" ;
573
		case 7:
574
			return "juillet" ;
575
		case 8:
576
			return "août" ;
577
		case 9:
578
			return "septembre" ;
579
		case 10:
580
			return "octobre" ;
581
		case 11:
582
			return "novembre" ;
583
		case 12:
584
			return "décembre" ;
585
		default:
586
			return "Inconnue" ;
587
		}
588
 
589
	}
590
 
591
 
592
}