Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | 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;
724 aurelien 11
import org.tela_botanica.client.util.Util;
638 aurelien 12
 
13
import com.gwtext.client.data.Node;
14
import com.gwtext.client.data.NodeTraversalCallback;
15
import com.gwtext.client.data.Tree;
16
import com.gwtext.client.widgets.Panel;
17
import com.gwtext.client.widgets.tree.TreeNode;
18
import com.gwtext.client.widgets.tree.TreePanel;
19
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
20
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
21
import com.gwtext.client.core.EventObject;
22
 
23
/**
24
 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
25
 * cliquable
26
 *
27
 * @author aurelien
28
 *
29
 */
30
public class ArbreDateImageFiltreVue extends Panel implements Rafraichissable,
31
		Filtrable {
32
 
33
	/**
34
	 * Le médiateur associé à la vue
35
	 */
36
	private ImageMediateur	imageMediateur		= null;
37
 
38
	/**
39
	 * Les localites en cours
40
	 */
41
	private String donneesDateEnCours = "";
42
 
43
	/**
44
	 * Le treepanel qui affiche l'arbre
45
	 */
46
	private TreePanel arbreDonneesDates = null;
47
 
48
	/**
49
	 * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
50
	 */
51
 
52
	private Tree donneesDates = new Tree();
53
 
54
	/**
55
	 * booléen d'initialisation
56
	 */
57
	private boolean estInstancie = false;
58
 
59
	/**
60
	 * booléen d'etat
61
	 */
62
	private boolean filtreModifie = false;
63
 
64
	private boolean arbreCharge = false ;
65
 
66
	private String nomFiltre = "" ;
67
 
68
	private String prefixeId = "date_image_";
69
 
70
	/**
71
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
72
	 */
73
	@SuppressWarnings("unused")
74
	private ArbreDateImageFiltreVue() {
75
		super();
76
	}
77
 
78
	/**
79
	 * Constructeur avec paramètres
80
	 *
81
	 * @param im
82
	 *            le médiateur à associer
83
	 */
84
	public ArbreDateImageFiltreVue(ImageMediateur imgMed) {
85
 
86
		// on crée le panel
87
		super("Dates");
88
 
89
		this.imageMediateur = imgMed;
90
 
91
		arbreDonneesDates = new TreePanel();
92
 
93
		this.setPaddings(5);
94
 
95
		this.setCollapsible(true);
96
		this.setAutoScroll(true);
97
		this.setBorder(false);
98
		arbreDonneesDates.setBorder(false);
99
 
100
		// on ajoute les listeners
101
		ajouterListenersPanel();
102
		estInstancie = false;
103
	}
104
 
105
	/**
106
	 * Ajoute les listeners pour le rendu du panel
107
	 */
108
	private void ajouterListenersPanel() {
109
 
110
		// on interdit le drag and drop dans l'arbre
111
		arbreDonneesDates.setEnableDD(false);
112
		arbreDonneesDates.setId("x-view-tree-filter-date-image");
113
 
114
		// on crée une racine pour l'arbre
115
		TreeNode root = new TreeNode("Dates");
116
 
117
		root.addListener(new TreeNodeListenerAdapter() {
118
 
1292 aurelien 119
			@Override
638 aurelien 120
			public void onExpand(Node node) {
121
 
122
				if(!arbreCharge)
123
				{
124
					obtenirDatesImages();
125
					arbreCharge = true ;
126
				}
127
			}
128
 
129
		}) ;
130
 
131
		root.setId("racine_date");
132
		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
133
		root.setUserObject(usObject);
134
 
135
		arbreDonneesDates.setRootNode(root);
136
		arbreDonneesDates.setRootVisible(true);
137
		setBorder(false);
138
		root.setExpandable(true) ;
139
 
140
		add(arbreDonneesDates);
141
 
142
		// enfin on considère le composant comme instancié
143
		estInstancie = true;
144
	}
145
 
146
 
147
 
148
	/**
149
	 * ajoute les listeners pour les boutons et le cochage des entites
150
	 */
151
	public void ajouterListeners() {
152
 
153
		arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
154
 
1292 aurelien 155
			@Override
638 aurelien 156
			public void onClick(TreeNode node, EventObject e) {
680 aurelien 157
				gererClicNoeud(node);
158
			}
638 aurelien 159
		}) ;
160
 
161
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
162
 
1292 aurelien 163
			@Override
638 aurelien 164
			public void onExpand(Node node) {
165
 
166
				if(!arbreCharge)
167
				{
168
					obtenirDatesImages();
169
					arbreCharge = true ;
170
				}
171
			}
172
 
173
		}) ;
174
	}
175
 
680 aurelien 176
	private void gererClicNoeud(TreeNode node) {
177
 
178
		mettreAJourValeurEnCours(node);
179
		imageMediateur.obtenirPhotoGalerie() ;
180
 
181
	}
182
 
183
	private void mettreAJourValeurEnCours(TreeNode node) {
184
 
185
		nomFiltre = "" ;
186
		donneesDateEnCours = "" ;
187
		String nomPere = "" ;
188
		String nomGrandPere = "" ;
189
 
190
		switch(node.getDepth())
191
		{
192
			case 0:
193
				if(arbreCharge) {
194
					nomFiltre = "";
195
					donneesDateEnCours = "";
196
				}
197
				break;
198
			case 3: nomFiltre += "annee,mois,jour";
199
				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
200
				nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
201
				donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
202
				break;
203
			case 2: nomFiltre += "annee,mois";
204
				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
205
				donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
206
				break;
207
			case 1: nomFiltre += "annee";
208
				donneesDateEnCours += ((String[])node.getUserObject())[1] ;
209
				break;
210
			default:
211
				break;
212
		}
213
 
214
		filtreModifie = true ;
215
	}
216
 
638 aurelien 217
	public void initialiser() {
218
 
219
		arbreCharge = false ;
220
		donneesDateEnCours = "";
221
		arbreDonneesDates.collapseAll();
222
 
223
		// on vide l'ancien arbre
224
		Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();
225
		for (int i = 0; i < rootChild.length; i++) {
226
 
227
			rootChild[i].remove();
228
		}
229
 
230
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
231
 
1292 aurelien 232
			@Override
638 aurelien 233
			public void onExpand(Node node) {
234
				if(!arbreCharge)
235
				{
236
					obtenirDatesImages() ;
237
					arbreCharge = true ;
238
				}
239
			}
240
 
241
		}) ;
242
	}
243
 
244
	/**
245
	 * Méthode héritée de l'interface rafraichissable
246
	 */
1292 aurelien 247
	@Override
638 aurelien 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
 
1292 aurelien 271
				DateObservation ent=data.get(it.next());
638 aurelien 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
 
1292 aurelien 362
					@Override
638 aurelien 363
					public boolean execute(Node node) {
364
 
365
						node.remove();
366
						return true;
367
					}
368
 
369
				});
370
 
371
				// et on recopie le nouvel arbre
372
				copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates
373
						.getRootNode());
374
 
375
				// si l'arbre n'était pas encore considéré comme instancié
376
				if (!estInstancie) {
377
					// on signale que oui
378
					estInstancie = true;
379
				}
380
 
381
 
382
				// l'état du filtre est réinitialisé
383
				filtreModifie = false;
384
				//show() ;
385
				doLayout();
386
 
387
			}
388
	}
389
 
390
 
391
	/**
392
	 * Accesseur pour le panneau contenant l'arbre
393
	 *
394
	 * @return le panneau de l'arbre des mots clés
395
	 */
396
	public TreePanel getArbreMotsCles() {
397
		return arbreDonneesDates;
398
	}
399
 
400
	/**
401
	 * Méthode héritée de Filtrable renvoie le nom du filtre
402
	 */
1292 aurelien 403
	@Override
638 aurelien 404
	public String renvoyerNomFiltre() {
405
 
406
		return "Dates";
407
	}
408
 
409
	/**
410
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
411
	 *
412
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
413
	 */
1292 aurelien 414
	@Override
638 aurelien 415
	public String[] renvoyerValeursAFiltrer() {
416
 
417
		valider();
418
 
419
		String[] valeursFiltrees = new String[0];
420
 
421
		if(!nomFiltre.trim().equals("") && !donneesDateEnCours.trim().equals("")) {
422
			valeursFiltrees = new String[2];
423
			valeursFiltrees[0] = nomFiltre;
424
			valeursFiltrees[1] = donneesDateEnCours;
425
		}
426
 
427
		return valeursFiltrees;
428
	}
429
 
430
	/**
431
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
432
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
433
	 *
434
	 * @param ndPereOriginal
435
	 *            le père des noeuds de l'arbre original
436
	 * @param ndPereCopie
437
	 *            le père qui va recevoir les copies
438
	 */
439
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
440
		if (ndPereCopie != null && ndPereOriginal != null) {
441
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
442
 
443
			for (int i = 0; i < ndNodeFils.length; i++) {
444
 
445
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
446
				TreeNode child = new TreeNode(usObj[0]);
447
				child.setUserObject(usObj);
448
				child.setId(prefixeId+usObj[2]);
449
				ndPereCopie.appendChild(child);
450
 
451
				if (!ndNodeFils[i].isLeaf()) {
452
					copierFilsNoeud(ndNodeFils[i], child);
453
				}
454
 
455
			}
456
		}
457
	}
458
 
459
	/**
460
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
461
	 */
1292 aurelien 462
	@Override
638 aurelien 463
	public boolean renvoyerEtatFiltre() {
464
 
465
		return filtreModifie;
466
	}
467
 
1292 aurelien 468
	@Override
638 aurelien 469
	public void valider() {
470
 
471
		if (estInstancie) {
472
 
473
		}
474
	}
475
 
476
	public Comparator<TreeNode> comparerNoeuds()
477
	{
478
		return new Comparator<TreeNode>() {
479
 
1292 aurelien 480
			@Override
638 aurelien 481
			public int compare(TreeNode o1, TreeNode o2) {
482
 
483
				String n1 = ((String[])o1.getUserObject())[1] ;
484
				String n2 = ((String[])o2.getUserObject())[1] ;
485
 
486
				return n1.compareTo(n2) ;
487
			}
488
 
489
		} ;
490
	}
491
 
492
	public void raz() {
493
 
494
		arbreCharge = false ;
495
		arbreDonneesDates.collapseAll();
496
		arbreDonneesDates.clear();
497
 
498
		TreeNode root = new TreeNode("Dates");
499
		root.setId("racine_date");
500
		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
501
		root.setUserObject(usObject);
502
 
503
		arbreDonneesDates.setRootNode(root);
504
 
505
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
506
 
1292 aurelien 507
			@Override
638 aurelien 508
			public void onExpand(Node node) {
509
				if(!arbreCharge)
510
				{
511
					obtenirDatesImages() ;
512
					arbreCharge = true ;
513
				}
514
			}
515
 
516
		}) ;
517
 
518
		this.doLayout() ;
519
 
520
		donneesDateEnCours = "";
521
 
522
	}
523
 
524
	public void obtenirDatesImages() {
525
		imageMediateur.obtenirDatesImages(this);
526
	}
527
 
1292 aurelien 528
	@Override
680 aurelien 529
	public void viderFiltre() {
530
		donneesDateEnCours = "";
531
		arbreDonneesDates.getSelectionModel().clearSelections();
532
	}
638 aurelien 533
 
680 aurelien 534
	public void viderFiltre(String nom) {
535
 
536
		final int profondeur = calculerProfondeurPourNomFiltre(nom);
537
 
538
		// on vide tous les noeuds
539
		arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() {
540
 
1292 aurelien 541
			@Override
680 aurelien 542
			public boolean execute(Node node) {
543
 
544
				boolean continuer = true;
545
 
546
				TreeNode noeudArbreEncours = (TreeNode)node;
547
 
548
				if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) {
549
 
550
					int profondeurDepart = noeudArbreEncours.getDepth();
551
 
552
					for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) {
553
						noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode();
554
					}
555
 
556
					arbreDonneesDates.getSelectionModel().select(noeudArbreEncours);
557
					mettreAJourValeurEnCours(noeudArbreEncours);
558
 
559
					continuer = false;
560
				}
561
 
562
				return continuer;
563
			}
564
 
565
		});
566
	}
567
 
568
	private int calculerProfondeurPourNomFiltre(String nom) {
569
 
570
		int profondeur = 0;
571
 
572
		if(nom.equals("annee")) {
573
			profondeur = 1;
574
		}
575
 
576
		if(nom.equals("mois")) {
577
			profondeur = 2;
578
		}
579
 
580
		if(nom.equals("jour")) {
581
			profondeur = 3;
582
		}
583
 
584
		return profondeur;
585
	}
586
 
587
 
638 aurelien 588
}