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