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;
109 aurelien 33
import com.gwtext.client.core.Ext;
34
import com.gwtext.client.core.ExtElement;
91 jpm 35
 
36
/**
37
 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
38
 * cliquable
39
 *
40
 * @author aurelien
41
 *
42
 */
43
public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable,
44
		Filtrable {
45
 
46
	/**
47
	 * Le médiateur associé à la vue
48
	 */
49
	private ObservationMediateur	observationMediateur		= null;
50
 
51
	/**
52
	 * Les localites en cours
53
	 */
54
	private String donneesDateEnCours = "";
55
 
56
	/**
57
	 * Le treepanel qui affiche l'arbre
58
	 */
59
	private TreePanel arbreDonneesDates = null;
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
						{
109 aurelien 183
							ExtElement masked = Ext.get(arbreDonneesDates.getId());
184
							masked.mask("Chargement");
91 jpm 185
							arbreCharge = true ;
186
							observationMediateur.obtenirDatesObservation() ;
187
						}
188
						else
189
						{
190
							observationMediateur.obtenirNombreObservation() ;
191
						}
192
						return ;
193
					case 3: nomFiltre += "annee,mois,jour";
94 jpm 194
						nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
195
						nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
196
						donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
91 jpm 197
						break;
198
					case 2: nomFiltre += "annee,mois";
94 jpm 199
						nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
200
						donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
91 jpm 201
						break;
202
					case 1: nomFiltre += "annee";
94 jpm 203
						donneesDateEnCours += ((String[])node.getUserObject())[1] ;
91 jpm 204
						break;
205
					default:
206
						break;
207
				}
208
 
209
				filtreModifie = true ;
210
				observationMediateur.obtenirNombreObservation() ;
211
 
212
			}
213
 
214
		}) ;
215
 
216
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
217
 
218
			public void onExpand(Node node) {
219
				if(!arbreCharge)
220
				{
109 aurelien 221
					ExtElement masked = Ext.get(arbreDonneesDates.getId());
222
					masked.mask("Chargement");
91 jpm 223
					observationMediateur.obtenirDatesObservation() ;
224
					arbreCharge = true ;
225
				}
226
			}
227
 
228
		}) ;
229
	}
230
 
231
	/**
232
	 * Méthode héritée de l'interface rafraichissable
233
	 */
234
	public void rafraichir(Object nouvelleDonnees,
235
			boolean repandreRaffraichissement) {
236
 
237
		if (nouvelleDonnees instanceof ListeDateObservation) {
238
 
239
			String annee=null;
240
			String mois=null;
241
			String jour=null;
242
 
243
			ListeDateObservation data = (ListeDateObservation) nouvelleDonnees ;
244
 
245
				// on crée un arbre vide
246
				TreeNode root = new TreeNode();
247
				root.setId("racine_date");
248
				root.setText("Dates");
94 jpm 249
				String[] usObjRoot = { "Dates", "Dates"};
91 jpm 250
				root.setUserObject(usObjRoot);
251
				donneesDates.setRootNode(root);
252
 
253
			// on la parse et on récupère les informations qui nous interessent
254
			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
255
 
256
				DateObservation ent=(DateObservation) data.get(it.next());
257
 
258
				annee= ent.getAnnee() ;
259
				mois= ent.getMois() ;
260
				String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
261
				jour= ent.getJour() ;
262
 
263
				if(annee.contains("0000")) {
264
					annee="Inconnue" ;
265
				}
266
 
267
				if(jour.contains("00")) {
268
					jour="Inconnue" ;
269
				}
270
 
94 jpm 271
				Node noeudMemeAnnee = donneesDates.getNodeById(""+annee);
91 jpm 272
				// si la région existe déjà
94 jpm 273
					if(noeudMemeAnnee != null)
91 jpm 274
					{
275
						// on teste si la localité existe
94 jpm 276
						Node noeudMemeMois = donneesDates.getNodeById(""+(annee+mois));
277
						if(noeudMemeMois != null)
91 jpm 278
						{
279
							// enfin on teste si le lieu dit existe
94 jpm 280
							Node noeudMemeJour = donneesDates.getNodeById(""+(annee+mois+jour));
281
							if(noeudMemeJour != null)
91 jpm 282
							{
283
								// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
284
							}
285
							else
286
							{
287
								// enfin on ne crée que le noeud du lieu dit
94 jpm 288
								TreeNode node_jour = new TreeNode();
289
								node_jour.setId(""+(annee+mois+jour));
290
								node_jour.setText(jour);
291
								noeudMemeMois.appendChild(node_jour) ;
292
								String[] usObj = {jour,jour};
293
								node_jour.setUserObject(usObj);
91 jpm 294
							}
295
						}
296
						else
297
						{
94 jpm 298
							TreeNode node_mois = new TreeNode();
299
							node_mois.setId(""+(annee+mois));
300
							node_mois.setText(moisLettre);
301
							noeudMemeAnnee.appendChild(node_mois) ;
302
							String[] usObj = {moisLettre,mois};
303
							node_mois.setUserObject(usObj);
91 jpm 304
 
94 jpm 305
							TreeNode node_jour = new TreeNode();
306
							node_jour.setId(""+(annee+mois+jour));
307
							node_jour.setText(jour);
308
							node_mois.appendChild(node_jour) ;
309
							String[] usObj2 = {jour,jour};
310
							node_jour.setUserObject(usObj2);
91 jpm 311
 
312
						}
313
					}
314
					else
315
					{
94 jpm 316
						TreeNode node_annee = new TreeNode();
317
						node_annee.setId(""+annee);
318
						node_annee.setText(annee);
319
						root.appendChild(node_annee) ;
320
						String[] usObj = {annee, annee};
321
						node_annee.setUserObject(usObj);
91 jpm 322
 
94 jpm 323
						TreeNode node_mois = new TreeNode();
324
						node_mois.setId(""+(annee+mois));
325
						node_mois.setText(moisLettre);
326
						node_annee.appendChild(node_mois) ;
327
						String[] usObj2 = {moisLettre,mois};
328
						node_mois.setUserObject(usObj2);
91 jpm 329
 
94 jpm 330
						TreeNode node_jour = new TreeNode();
331
						node_jour.setId(""+(annee+mois+jour));
332
						node_jour.setText(jour);
333
						node_mois.appendChild(node_jour) ;
334
						String[] usObj3 = {jour,jour};
335
						node_jour.setUserObject(usObj3);
91 jpm 336
					}
337
 
338
				}
339
 
340
				// on vide tous les noeuds
341
				arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
342
 
343
					public boolean execute(Node node) {
344
 
345
						node.remove();
346
						return true;
347
					}
348
 
349
				});
350
 
351
				// et on recopie le nouvel arbre
352
				copierFilsNoeud(donneesDates.getRootNode(), arbreDonneesDates
353
						.getRootNode());
354
 
94 jpm 355
				// on trie
356
				root.sort(comparerNoeuds()) ;
357
 
91 jpm 358
				// si l'arbre n'était pas encore considéré comme instancié
359
				if (!estInstancie) {
360
					// on signale que oui
361
					estInstancie = true;
362
				}
109 aurelien 363
 
364
				ExtElement masked = Ext.get(arbreDonneesDates.getId());
365
				masked.unmask();
91 jpm 366
 
367
				// l'état du filtre est réinitialisé
368
				filtreModifie = false;
369
				//show() ;
370
				doLayout();
371
 
372
			}
373
 
94 jpm 374
		if(nouvelleDonnees instanceof Observation)
91 jpm 375
		{
94 jpm 376
			Observation ent = (Observation)nouvelleDonnees ;
377
			String dateSpl[] = ent.getDate().split("/") ;
91 jpm 378
 
94 jpm 379
			String annee= dateSpl[2];
380
			String mois= dateSpl[1];
381
			String jour= dateSpl[0];
382
 
91 jpm 383
			String moisLettre = renvoyerMois(Integer.parseInt(mois)) ;
384
 
385
			Node root = arbreDonneesDates.getRootNode() ;
386
 
387
			if(annee.contains("0000") || annee.equals(null)) {
388
				annee="Inconnue" ;
389
			}
390
 
391
			if(jour.contains("00") || jour.equals(null)) {
392
				jour="Inconnue" ;
393
			}
394
 
94 jpm 395
			Node noeudMemeAnnee = donneesDates.getNodeById(""+annee);
91 jpm 396
			// si la région existe déjà
94 jpm 397
				if(noeudMemeAnnee != null)
398
				{
91 jpm 399
					// on teste si la localité existe
94 jpm 400
					Node noeudMemeMois = donneesDates.getNodeById(""+(annee+mois));
401
					if(noeudMemeMois != null)
91 jpm 402
					{
403
						// enfin on teste si le lieu dit existe
94 jpm 404
						Node noeudMemeJour = donneesDates.getNodeById(""+(annee+mois+jour));
405
						if(noeudMemeJour != null)
91 jpm 406
						{
407
							// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
408
						}
409
						else
410
						{
411
							// enfin on ne crée que le noeud du lieu dit
94 jpm 412
							TreeNode node_jour = new TreeNode();
413
							node_jour.setId(""+(annee+mois+jour));
414
							node_jour.setText(jour);
415
							String[] usObj = {jour,jour};
416
							node_jour.setUserObject(usObj);
417
							noeudMemeMois.appendChild(node_jour) ;
418
 
419
							root.sort(comparerNoeuds()) ;
91 jpm 420
						}
421
					}
422
					else
423
					{
94 jpm 424
						TreeNode node_mois = new TreeNode();
425
						node_mois.setId(""+(annee+mois));
426
						node_mois.setText(moisLettre);
427
						String[] usObj = {moisLettre,mois};
428
						node_mois.setUserObject(usObj);
429
						noeudMemeAnnee.appendChild(node_mois) ;
91 jpm 430
 
94 jpm 431
						Window.alert("on crée on nouveau mois "+node_mois.getId()) ;
91 jpm 432
 
94 jpm 433
						TreeNode node_jour = new TreeNode();
434
						node_jour.setId(""+(annee+mois+jour));
435
						node_jour.setText(jour);
436
						String[] usObj2 = {jour,jour};
437
						node_jour.setUserObject(usObj2);
438
						node_mois.appendChild(node_jour) ;
439
 
440
						root.sort(comparerNoeuds()) ;
91 jpm 441
					}
442
			}
443
			else
444
			{
445
 
94 jpm 446
				TreeNode node_annee = new TreeNode();
447
				node_annee.setId(""+annee);
448
				node_annee.setText(annee);
449
				String[] usObj = {annee,annee};
450
				node_annee.setUserObject(usObj);
451
				root.appendChild(node_annee) ;
91 jpm 452
 
94 jpm 453
				TreeNode node_mois = new TreeNode();
454
				node_mois.setId(""+(annee+mois));
455
				node_mois.setText(moisLettre);
456
				String[] usObj2 = {moisLettre,mois};
457
				node_mois.setUserObject(usObj2);
458
				node_annee.appendChild(node_mois) ;
91 jpm 459
 
94 jpm 460
				TreeNode node_jour = new TreeNode();
461
				node_jour.setId(""+(annee+mois+jour));
462
				node_jour.setText(jour);
463
				String[] usObj3 = {jour,jour};
464
				node_jour.setUserObject(usObj3);
465
				node_mois.appendChild(node_jour) ;
91 jpm 466
 
467
				// TODO : améliorer la compararaison des noeuds
468
				root.sort(comparerNoeuds()) ;
469
			}
470
 
471
				arbreDonneesDates.doLayout() ;
472
		}
473
	}
474
 
475
 
476
	/**
477
	 * Accesseur pour le panneau contenant l'arbre
478
	 *
479
	 * @return le panneau de l'arbre des mots clés
480
	 */
481
	public TreePanel getArbreMotsCles() {
482
		return arbreDonneesDates;
483
	}
484
 
485
	/**
486
	 * Méthode héritée de Filtrable renvoie le nom du filtre
487
	 */
488
	public String renvoyerNomFiltre() {
489
 
490
		return "Dates";
491
	}
492
 
493
	/**
494
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
495
	 *
496
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
497
	 */
498
	public String[] renvoyerValeursAFiltrer() {
499
 
500
		valider();
501
 
502
		String valeursFiltrees[] = {nomFiltre, donneesDateEnCours } ;
503
 
504
		return valeursFiltrees;
505
	}
506
 
507
	/**
508
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
509
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
510
	 *
511
	 * @param ndPereOriginal
512
	 *            le père des noeuds de l'arbre original
513
	 * @param ndPereCopie
514
	 *            le père qui va recevoir les copies
515
	 */
516
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
517
		if (ndPereCopie != null && ndPereOriginal != null) {
518
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
519
 
520
			for (int i = 0; i < ndNodeFils.length; i++) {
521
 
522
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
523
				TreeNode child = new TreeNode(usObj[0]);
524
				child.setUserObject(usObj);
525
				ndPereCopie.appendChild(child);
526
 
527
				if (!ndNodeFils[i].isLeaf()) {
528
					copierFilsNoeud(ndNodeFils[i], child);
529
				}
530
 
531
			}
532
		}
533
	}
534
 
535
	/**
536
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
537
	 */
538
	public boolean renvoyerEtatFiltre() {
539
 
540
		return filtreModifie;
541
	}
542
 
543
	public void valider() {
544
 
545
		if (estInstancie) {
546
 
547
		}
548
	}
549
 
550
	public Comparator<TreeNode> comparerNoeuds()
551
	{
552
		return new Comparator<TreeNode>() {
553
 
554
			public int compare(TreeNode o1, TreeNode o2) {
555
 
94 jpm 556
				String n1 = ((String[])o1.getUserObject())[1] ;
557
				String n2 = ((String[])o2.getUserObject())[1] ;
91 jpm 558
 
559
				return n1.compareTo(n2) ;
560
			}
561
 
562
		} ;
563
	}
564
 
565
	public String renvoyerMois(int numMois) {
566
 
567
		switch (numMois) {
568
		case 1:
569
			return "janvier" ;
570
		case 2:
571
			return "fevrier" ;
572
		case 3:
573
			return "mars" ;
574
		case 4:
575
			return "avril" ;
576
		case 5:
577
			return "mai" ;
578
		case 6:
579
			return "juin" ;
580
		case 7:
581
			return "juillet" ;
582
		case 8:
583
			return "août" ;
584
		case 9:
585
			return "septembre" ;
586
		case 10:
587
			return "octobre" ;
588
		case 11:
589
			return "novembre" ;
590
		case 12:
591
			return "décembre" ;
592
		default:
593
			return "Inconnue" ;
594
		}
595
 
596
	}
597
 
104 jpm 598
	public void raz() {
599
 
600
		arbreCharge = false ;
601
		arbreDonneesDates.clear() ;
602
 
603
		TreeNode root = new TreeNode("Dates");
604
		root.setId("racine_date");
605
		String[] usObject = { "Dates" };
606
		root.setUserObject(usObject);
91 jpm 607
 
104 jpm 608
		arbreDonneesDates.setRootNode(root);
609
 
610
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
611
 
612
			public void onExpand(Node node) {
613
				if(!arbreCharge)
614
				{
615
					observationMediateur.obtenirDatesObservation() ;
616
					arbreCharge = true ;
617
				}
618
			}
619
 
620
		}) ;
621
 
622
		this.doLayout() ;
623
 
624
	}
625
 
626
 
91 jpm 627
}