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