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
	/**
53
	 * booléen d'initialisation
54
	 */
55
	private boolean estInstancie = false;
56
 
57
	/**
58
	 * booléen d'etat
59
	 */
60
	private boolean filtreModifie = false;
61
 
62
	private boolean arbreCharge = false ;
63
 
64
	private String nomFiltre = "" ;
65
 
66
	private String prefixeId = "date_image_";
67
 
68
	/**
69
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
70
	 */
71
	@SuppressWarnings("unused")
72
	private ArbreDateImageFiltreVue() {
73
		super();
74
	}
75
 
76
	/**
77
	 * Constructeur avec paramètres
78
	 *
79
	 * @param im
80
	 *            le médiateur à associer
81
	 */
82
	public ArbreDateImageFiltreVue(ImageMediateur imgMed) {
83
 
84
		// on crée le panel
85
		super("Dates");
86
 
87
		this.imageMediateur = imgMed;
88
 
89
		arbreDonneesDates = new TreePanel();
90
 
91
		this.setPaddings(5);
92
 
93
		this.setCollapsible(true);
94
		this.setAutoScroll(true);
95
		this.setBorder(false);
96
		arbreDonneesDates.setBorder(false);
97
 
98
		// on ajoute les listeners
99
		ajouterListenersPanel();
100
		estInstancie = false;
101
	}
102
 
103
	/**
104
	 * Ajoute les listeners pour le rendu du panel
105
	 */
106
	private void ajouterListenersPanel() {
107
 
108
		// on interdit le drag and drop dans l'arbre
109
		arbreDonneesDates.setEnableDD(false);
110
		arbreDonneesDates.setId("x-view-tree-filter-date-image");
111
 
112
		// on crée une racine pour l'arbre
113
		TreeNode root = new TreeNode("Dates");
114
 
115
		root.addListener(new TreeNodeListenerAdapter() {
116
 
1292 aurelien 117
			@Override
638 aurelien 118
			public void onExpand(Node node) {
119
 
120
				if(!arbreCharge)
121
				{
122
					obtenirDatesImages();
123
					arbreCharge = true ;
124
				}
125
			}
126
 
127
		}) ;
128
 
129
		root.setId("racine_date");
130
		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
131
		root.setUserObject(usObject);
132
 
133
		arbreDonneesDates.setRootNode(root);
134
		arbreDonneesDates.setRootVisible(true);
135
		setBorder(false);
136
		root.setExpandable(true) ;
137
 
138
		add(arbreDonneesDates);
139
 
140
		// enfin on considère le composant comme instancié
141
		estInstancie = true;
142
	}
143
 
144
 
145
 
146
	/**
147
	 * ajoute les listeners pour les boutons et le cochage des entites
148
	 */
149
	public void ajouterListeners() {
150
 
151
		arbreDonneesDates.addListener(new TreePanelListenerAdapter() {
152
 
1292 aurelien 153
			@Override
638 aurelien 154
			public void onClick(TreeNode node, EventObject e) {
680 aurelien 155
				gererClicNoeud(node);
156
			}
638 aurelien 157
		}) ;
158
 
159
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
160
 
1292 aurelien 161
			@Override
638 aurelien 162
			public void onExpand(Node node) {
163
 
164
				if(!arbreCharge)
165
				{
166
					obtenirDatesImages();
167
					arbreCharge = true ;
168
				}
169
			}
170
 
171
		}) ;
172
	}
173
 
680 aurelien 174
	private void gererClicNoeud(TreeNode node) {
175
 
176
		mettreAJourValeurEnCours(node);
177
		imageMediateur.obtenirPhotoGalerie() ;
178
 
179
	}
180
 
181
	private void mettreAJourValeurEnCours(TreeNode node) {
182
 
183
		nomFiltre = "" ;
184
		donneesDateEnCours = "" ;
185
		String nomPere = "" ;
186
		String nomGrandPere = "" ;
187
 
188
		switch(node.getDepth())
189
		{
190
			case 0:
191
				if(arbreCharge) {
192
					nomFiltre = "";
193
					donneesDateEnCours = "";
194
				}
195
				break;
196
			case 3: nomFiltre += "annee,mois,jour";
197
				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
198
				nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ;
199
				donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ;
200
				break;
201
			case 2: nomFiltre += "annee,mois";
202
				nomPere = ((String[])node.getParentNode().getUserObject())[1] ;
203
				donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ;
204
				break;
205
			case 1: nomFiltre += "annee";
206
				donneesDateEnCours += ((String[])node.getUserObject())[1] ;
207
				break;
208
			default:
209
				break;
210
		}
211
 
212
		filtreModifie = true ;
213
	}
214
 
638 aurelien 215
	public void initialiser() {
216
 
217
		arbreCharge = false ;
218
		donneesDateEnCours = "";
219
		arbreDonneesDates.collapseAll();
220
 
221
		// on vide l'ancien arbre
222
		Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes();
223
		for (int i = 0; i < rootChild.length; i++) {
224
 
225
			rootChild[i].remove();
226
		}
227
 
228
		arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() {
229
 
1292 aurelien 230
			@Override
638 aurelien 231
			public void onExpand(Node node) {
232
				if(!arbreCharge)
233
				{
234
					obtenirDatesImages() ;
235
					arbreCharge = true ;
236
				}
237
			}
238
 
239
		}) ;
240
	}
241
 
242
	/**
243
	 * Méthode héritée de l'interface rafraichissable
244
	 */
1292 aurelien 245
	@Override
638 aurelien 246
	public void rafraichir(Object nouvelleDonnees,
247
			boolean repandreRaffraichissement) {
248
 
249
		if (nouvelleDonnees instanceof ListeDate) {
250
 
251
			String annee=null;
252
			String mois=null;
253
			String jour=null;
254
 
255
			ListeDate data = (ListeDate) nouvelleDonnees ;
256
 
257
				// on crée un arbre vide
258
				TreeNode root = new TreeNode();
259
				root.setId("racine_date");
260
				root.setText("Dates");
261
				String[] usObjRoot = { "Dates", "Dates", prefixeId+"racine_date"};
262
				root.setUserObject(usObjRoot);
263
				Tree nouvelArbre = new Tree();
264
				nouvelArbre.setRootNode(root);
265
 
266
			// on la parse et on récupère les informations qui nous interessent
267
			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
268
 
1292 aurelien 269
				DateObservation ent=data.get(it.next());
638 aurelien 270
 
271
				annee= ent.getAnnee() ;
272
				mois= ent.getMois() ;
680 aurelien 273
				String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ;
638 aurelien 274
				jour= ent.getJour() ;
275
 
276
				if(annee.contains("0000")) {
277
					annee="Inconnue" ;
278
				}
279
 
280
				if(jour.contains("00")) {
281
					jour="Inconnue" ;
282
				}
283
 
284
				Node noeudMemeAnnee = nouvelArbre.getNodeById(prefixeId+annee);
285
				// si la région existe déjà
286
					if(noeudMemeAnnee != null)
287
					{
288
						// on teste si la localité existe
289
						Node noeudMemeMois = nouvelArbre.getNodeById(prefixeId+(annee+mois));
290
						if(noeudMemeMois != null)
291
						{
292
							// enfin on teste si le lieu dit existe
293
							Node noeudMemeJour = nouvelArbre.getNodeById(prefixeId+(annee+mois+jour));
294
							if(noeudMemeJour != null)
295
							{
296
								// tous les noeuds existent déjà, normalement ça ne devrait pas arriver
297
							}
298
							else
299
							{
300
								// enfin on ne crée que le noeud du lieu dit
301
								TreeNode node_jour = new TreeNode();
302
								node_jour.setId(prefixeId+(annee+mois+jour));
303
								node_jour.setText(jour);
304
								noeudMemeMois.appendChild(node_jour) ;
305
								String[] usObj = {jour,jour,annee+mois+jour};
306
								node_jour.setUserObject(usObj);
307
							}
308
						}
309
						else
310
						{
311
							TreeNode node_mois = new TreeNode();
312
							node_mois.setId(prefixeId+(annee+mois));
313
							node_mois.setText(moisLettre);
314
							noeudMemeAnnee.appendChild(node_mois) ;
315
							String[] usObj = {moisLettre,mois,annee+mois};
316
							node_mois.setUserObject(usObj);
317
 
318
							TreeNode node_jour = new TreeNode();
319
							node_jour.setId(prefixeId+(annee+mois+jour));
320
							node_jour.setText(jour);
321
							node_mois.appendChild(node_jour) ;
322
							String[] usObj2 = {jour,jour,annee+mois+jour};
323
							node_jour.setUserObject(usObj2);
324
 
325
						}
326
					}
327
					else
328
					{
329
						TreeNode node_annee = new TreeNode();
330
						node_annee.setId(prefixeId+annee);
331
						node_annee.setText(annee);
332
						root.appendChild(node_annee) ;
333
						String[] usObj = {annee, annee, annee};
334
						node_annee.setUserObject(usObj);
335
 
336
						TreeNode node_mois = new TreeNode();
337
						node_mois.setId(prefixeId+(annee+mois));
338
						node_mois.setText(moisLettre);
339
						node_annee.appendChild(node_mois) ;
340
						String[] usObj2 = {moisLettre,mois,annee+mois};
341
						node_mois.setUserObject(usObj2);
342
 
343
						TreeNode node_jour = new TreeNode();
344
						node_jour.setId(prefixeId+(annee+mois+jour));
345
						node_jour.setText(jour);
346
						node_mois.appendChild(node_jour) ;
347
						String[] usObj3 = {jour,jour,annee+mois+jour};
348
						node_jour.setUserObject(usObj3);
349
					}
350
 
351
				}
352
 
353
 
354
				// on trie
355
				root.sort(comparerNoeuds()) ;
356
 
357
				// on vide tous les noeuds
358
				arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() {
359
 
1292 aurelien 360
					@Override
638 aurelien 361
					public boolean execute(Node node) {
362
 
363
						node.remove();
364
						return true;
365
					}
366
 
367
				});
368
 
369
				// et on recopie le nouvel arbre
370
				copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates
371
						.getRootNode());
372
 
373
				// si l'arbre n'était pas encore considéré comme instancié
374
				if (!estInstancie) {
375
					// on signale que oui
376
					estInstancie = true;
377
				}
378
 
379
 
380
				// l'état du filtre est réinitialisé
381
				filtreModifie = false;
382
				//show() ;
383
				doLayout();
384
 
385
			}
386
	}
387
 
388
 
389
	/**
390
	 * Accesseur pour le panneau contenant l'arbre
391
	 *
392
	 * @return le panneau de l'arbre des mots clés
393
	 */
394
	public TreePanel getArbreMotsCles() {
395
		return arbreDonneesDates;
396
	}
397
 
398
	/**
399
	 * Méthode héritée de Filtrable renvoie le nom du filtre
400
	 */
1292 aurelien 401
	@Override
638 aurelien 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
	 */
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
 
496
		TreeNode root = new TreeNode("Dates");
497
		root.setId("racine_date");
498
		String[] usObject = { "Dates", "Dates", prefixeId+"racine_date" };
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
}