Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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