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