Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
54 david 1
package org.tela_botanica.client.vues;
2
 
68 david 3
import java.util.Iterator;
4
 
54 david 5
import org.tela_botanica.client.interfaces.Filtrable;
6
import org.tela_botanica.client.interfaces.Rafraichissable;
68 david 7
import org.tela_botanica.client.modeles.EntiteGeographiqueObservation;
8
import org.tela_botanica.client.modeles.ListeEntiteGeographiqueObservation;
54 david 9
import org.tela_botanica.client.observation.ObservationMediateur;
10
 
72 david 11
import com.google.gwt.core.client.GWT;
68 david 12
import com.google.gwt.json.client.JSONArray;
13
import com.google.gwt.json.client.JSONObject;
14
import com.google.gwt.user.client.Window;
54 david 15
import com.google.gwt.user.client.ui.Label;
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
 
25
/**
26
 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
27
 * cliquable
28
 *
29
 * @author aurelien
30
 *
31
 */
68 david 32
public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable,
54 david 33
		Filtrable {
34
 
35
	/**
36
	 * Le médiateur associé à la vue
37
	 */
38
	private ObservationMediateur	observationMediateur		= null;
39
 
40
	/**
41
	 * Les localites en cours
42
	 */
68 david 43
	private String entitesGeographiquesEncours = "";
54 david 44
 
45
	/**
46
	 * Le treepanel qui affiche l'arbre
47
	 */
68 david 48
	private TreePanel arbreEntitesGeographiques = null;
54 david 49
 
68 david 50
 
51
 
54 david 52
	/**
68 david 53
	 * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue
54
	 */
55
 
56
	private Tree donneeEntitesGeographiques = new Tree();;
57
 
58
	/**
54 david 59
	 * booléen d'initialisation
60
	 */
61
	private boolean estInstancie = false;
62
 
63
	/**
64
	 * booléen d'etat
65
	 */
66
	private boolean filtreModifie = false;
67
 
68
	/**
69
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
70
	 */
71
	@SuppressWarnings("unused")
68 david 72
	private ArbreEntiteGeographiqueObservationFiltreVue() {
54 david 73
		super();
74
	}
75
 
76
	/**
77
	 * Constructeur avec paramètres
78
	 *
79
	 * @param im
80
	 *            le médiateur à associer
81
	 */
68 david 82
	public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) {
54 david 83
 
84
		// on crée le panel
70 david 85
		super("Localité");
54 david 86
 
87
		this.observationMediateur = obs;
88
 
68 david 89
		arbreEntitesGeographiques = new TreePanel();
54 david 90
 
91
		this.setPaddings(5);
92
 
93
		this.setBorder(false);
94
		this.setCollapsible(true);
95
		this.setAutoWidth(true);
96
 
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() {
68 david 107
		  this.addListener(new PanelListenerAdapter() {
54 david 108
 
109
			// on instancie réellement les composants au moment du rendu pour
110
			// accélérer l'affichage
111
			// et éviter des bugs
112
			public void onRender(Component component) {
113
 
114
				// on interdit le drag and drop dans l'arbre
68 david 115
				arbreEntitesGeographiques.setEnableDD(false);
73 david 116
				arbreEntitesGeographiques.setId("x-view-tree-filter-entity");
72 david 117
				arbreEntitesGeographiques.setAutoWidth(false);
118
 
119
				if (GWT.isScript()) {
120
					arbreEntitesGeographiques.setAutoScroll(true);
121
				}
122
 
123
				arbreEntitesGeographiques.setBorder(false);
54 david 124
 
125
				// on crée une racine pour l'arbre
72 david 126
				TreeNode root = new TreeNode("Localités");
70 david 127
				root.setId("racine_entite");
72 david 128
				String[] usObject = { "Localités" };
54 david 129
				root.setUserObject(usObject);
130
 
68 david 131
				arbreEntitesGeographiques.setRootNode(root);
132
				arbreEntitesGeographiques.setRootVisible(true);
133
				arbreEntitesGeographiques.setBorder(false);
54 david 134
 
68 david 135
				add(arbreEntitesGeographiques);
54 david 136
 
137
				// on ajoute les listeners d'évenements
138
				ajouterListeners();
139
 
140
 
141
				// enfin on considère le composant comme instancié
142
				estInstancie = true;
143
 
68 david 144
 
54 david 145
			}
146
 
147
		});
148
	}
149
 
68 david 150
 
151
 
54 david 152
	/**
70 david 153
	 * ajoute les listeners pour les boutons et le cochage des entites
54 david 154
	 */
155
	private void ajouterListeners() {
156
 
157
	}
158
 
159
	/**
160
	 * Méthode héritée de l'interface rafraichissable
161
	 */
162
	public void rafraichir(Object nouvelleDonnees,
163
			boolean repandreRaffraichissement) {
164
 
165
 
68 david 166
		if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) {
167
 
168
 
72 david 169
 
68 david 170
			String entite=null;
72 david 171
			String idEntite=null;
172
			String idParent=null;
68 david 173
 
174
			ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ;
175
 
176
 
177
			if (data.isEmpty()) {
178
				// on crée un arbre vide
179
				TreeNode root = new TreeNode();
72 david 180
				root.setId("racine_entite");
181
				root.setText("Localités");
182
				String[] usObj = { "Localités"};
68 david 183
				root.setUserObject(usObj);
184
				donneeEntitesGeographiques.setRootNode(root);
185
 
186
			}
187
 
188
			// on la parse et on récupère les informations quiç nous interessent
189
			for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) {
190
 
191
				EntiteGeographiqueObservation ent=(EntiteGeographiqueObservation) data.get(it.next());
192
 
193
				entite=ent.getEntite();
73 david 194
 
195
 
196
				if(entite.equals("000null") ) {
197
					entite="Inconnue";
198
				}
72 david 199
				idEntite=ent.getIdEntite();
200
				idParent=ent.getIdParent();
68 david 201
 
72 david 202
 
68 david 203
				String[] usObj = { entite };
204
 
205
					// et on construit l'arbre à partir de la racine (qui est
206
					// toujours le premier élément)
72 david 207
					if (entite.equals("racine_entite")) {
68 david 208
						TreeNode root = new TreeNode();
72 david 209
						root.setId(idEntite);
68 david 210
						root.setText(entite);
211
						root.setUserObject(usObj);
212
						donneeEntitesGeographiques.setRootNode(root);
213
					} else {
214
						// et en ajoutant les noeuds un à un (qui sont renvoyé
215
						// dans l'ordre hierarchique de leur niveau
216
						// ce qui permet de les traiter séquentiellement)
217
						TreeNode node = new TreeNode();
72 david 218
						node.setId(idEntite);
219
						node.setText(entite);
220
						Node parentNode = donneeEntitesGeographiques.getNodeById(idParent);
68 david 221
						node.setUserObject(usObj);
222
						parentNode.appendChild(node);
223
					}
224
				}
225
 
226
			}
227
 
54 david 228
			// on vide tous les noeuds
68 david 229
			arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() {
54 david 230
 
231
				public boolean execute(Node node) {
232
 
233
					node.remove();
234
					return true;
235
				}
236
 
237
			});
238
 
239
			// et on recopie le nouvel arbre
68 david 240
			copierFilsNoeud(donneeEntitesGeographiques.getRootNode(), arbreEntitesGeographiques
54 david 241
					.getRootNode());
242
 
243
			// si l'arbre n'était pas encore considéré comme instancié
244
			if (!estInstancie) {
245
				// on signale que oui
246
				estInstancie = true;
247
			}
248
 
249
			// l'état du filtre est réinitialisé
250
			filtreModifie = false;
70 david 251
			//show() ;
252
			doLayout();
68 david 253
	}
254
 
54 david 255
 
68 david 256
 
54 david 257
 
258
 
259
	/**
260
	 * Accesseur pour le panneau contenant l'arbre
261
	 *
262
	 * @return le panneau de l'arbre des mots clés
263
	 */
264
	public TreePanel getArbreMotsCles() {
68 david 265
		return arbreEntitesGeographiques;
54 david 266
	}
267
 
268
	/**
269
	 * Méthode héritée de Filtrable renvoie le nom du filtre
270
	 */
271
	public String renvoyerNomFiltre() {
272
 
273
		return "Localités";
274
	}
275
 
276
	/**
277
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
278
	 *
279
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
280
	 */
281
	public String[] renvoyerValeursAFiltrer() {
282
 
283
		valider();
284
 
68 david 285
		String[] valeursFiltrees = { "localites", entitesGeographiquesEncours };
54 david 286
 
287
		return valeursFiltrees;
288
	}
289
 
290
	/**
291
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
292
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
293
	 *
294
	 * @param ndPereOriginal
295
	 *            le père des noeuds de l'arbre original
296
	 * @param ndPereCopie
297
	 *            le père qui va recevoir les copies
298
	 */
299
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
300
		if (ndPereCopie != null && ndPereOriginal != null) {
301
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
302
 
303
			for (int i = 0; i < ndNodeFils.length; i++) {
304
 
305
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
306
				TreeNode child = new TreeNode(usObj[0]);
68 david 307
				child.setId(usObj[0] + "_filtre");
54 david 308
				child.setUserObject(usObj);
309
				ndPereCopie.appendChild(child);
310
 
311
				if (!ndNodeFils[i].isLeaf()) {
312
					copierFilsNoeud(ndNodeFils[i], child);
313
				}
314
 
315
			}
316
		}
317
	}
318
 
319
	/**
320
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
321
	 */
322
	public boolean renvoyerEtatFiltre() {
323
 
324
		return filtreModifie;
325
	}
326
 
327
	public void valider() {
328
		if (estInstancie) {
329
			// on vide les mots clés en cours
68 david 330
			entitesGeographiquesEncours = "";
54 david 331
			// pour chaque noeud à partir de la racine
332
			getArbreMotsCles().getRootNode().cascade(
333
					new NodeTraversalCallback() {
334
 
335
						// on éxécute une fonction
336
						public boolean execute(Node node) {
337
 
338
							// on récupère le mot clé associé au noeud et ses
339
							// infos
340
							TreeNode tn = getArbreMotsCles().getNodeById(
341
									node.getId());
342
 
343
							String[] usObject = (String[]) tn.getUserObject();
68 david 344
							//observationMediateur.mettreAjourEntitesGeographiques(usObject[0],
54 david 345
								//	usObject[1]);
346
 
347
							if (tn.getUI().isChecked()) {
348
								// et les concatène à la string des mots clés en
349
								// cours
68 david 350
								entitesGeographiquesEncours += usObject[1] + ",";
54 david 351
							}
352
 
353
							return true;
354
						}
355
 
356
					});
357
 
358
			// on suppose que le filtre a change
359
			filtreModifie = true;
360
		}
361
	}
362
 
363
}