Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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