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
 
3
import org.tela_botanica.client.interfaces.Filtrable;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
5
import org.tela_botanica.client.observation.ObservationMediateur;
6
 
7
import com.google.gwt.user.client.ui.Label;
8
import com.gwtext.client.data.Node;
9
import com.gwtext.client.data.NodeTraversalCallback;
10
import com.gwtext.client.data.Tree;
11
import com.gwtext.client.widgets.Component;
12
import com.gwtext.client.widgets.Panel;
13
import com.gwtext.client.widgets.event.PanelListenerAdapter;
14
import com.gwtext.client.widgets.tree.TreeNode;
15
import com.gwtext.client.widgets.tree.TreePanel;
16
 
17
/**
18
 * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton
19
 * cliquable
20
 *
21
 * @author aurelien
22
 *
23
 */
24
public class ArbreLocaliteObservationFiltreVue extends Panel implements Rafraichissable,
25
		Filtrable {
26
 
27
	/**
28
	 * Le médiateur associé à la vue
29
	 */
30
	private ObservationMediateur	observationMediateur		= null;
31
 
32
	/**
33
	 * Les localites en cours
34
	 */
35
	private String localitesEncours = "";
36
 
37
	/**
38
	 * Le treepanel qui affiche l'arbre
39
	 */
40
	private TreePanel arbreLocalites = null;
41
 
42
	/**
43
	 * booléen d'initialisation
44
	 */
45
	private boolean estInstancie = false;
46
 
47
	/**
48
	 * booléen d'etat
49
	 */
50
	private boolean filtreModifie = false;
51
 
52
	/**
53
	 * Constructeur sans argument (privé car ne doit pas être utilisé)
54
	 */
55
	@SuppressWarnings("unused")
56
	private ArbreLocaliteObservationFiltreVue() {
57
		super();
58
	}
59
 
60
	/**
61
	 * Constructeur avec paramètres
62
	 *
63
	 * @param im
64
	 *            le médiateur à associer
65
	 */
66
	public ArbreLocaliteObservationFiltreVue(ObservationMediateur obs) {
67
 
68
		// on crée le panel
69
		super();
70
 
71
		this.observationMediateur = obs;
72
 
73
		// on crée le conteneur de l'arbre
74
		Label labelRecherche = new Label("Localités :");
75
		arbreLocalites = new TreePanel();
76
 
77
		this.setPaddings(5);
78
 
79
		this.setBorder(false);
80
		this.setCollapsible(true);
81
		this.setAutoWidth(true);
82
 
83
		add(labelRecherche);
84
 
85
		// on ajoute les listeners
86
		ajouterListenersPanel();
87
		estInstancie = false;
88
	}
89
 
90
	/**
91
	 * Ajoute les listeners pour le rendu du panel
92
	 */
93
	private void ajouterListenersPanel() {
94
		this.addListener(new PanelListenerAdapter() {
95
 
96
			// on instancie réellement les composants au moment du rendu pour
97
			// accélérer l'affichage
98
			// et éviter des bugs
99
			@Override
100
			public void onRender(Component component) {
101
 
102
				// on interdit le drag and drop dans l'arbre
103
				arbreLocalites.setEnableDD(false);
104
				arbreLocalites.setId("x-view-tree-filter");
105
				arbreLocalites.setAutoWidth(false);
106
				arbreLocalites.setAutoScroll(true);
107
				arbreLocalites.setBorder(false);
108
 
109
				// on crée une racine pour l'arbre
110
				TreeNode root = new TreeNode("Tags");
111
				root.setId("racine_filtre");
112
				String[] usObject = { "Localités", "racine" };
113
				root.setUserObject(usObject);
114
 
115
				arbreLocalites.setRootNode(root);
116
				arbreLocalites.setRootVisible(true);
117
				arbreLocalites.setBorder(false);
118
 
119
				// on met en forme le layout
120
				((Panel) component).add(arbreLocalites);
121
 
122
				// on ajoute les listeners d'évenements
123
				ajouterListeners();
124
 
125
 
126
				// et on demande l'arbre des localites
127
 
128
				observationMediateur.obtenirArbreLocalites(observationMediateur.getPanneauFiltres().getArbreLocaliteObservationFiltreVue());
129
 
130
 
131
 
132
				// enfin on considère le composant comme instancié
133
				estInstancie = true;
134
 
135
			}
136
 
137
		});
138
	}
139
 
140
	/**
141
	 * ajoute les listeners pour les boutons et le cochage des mots clés
142
	 */
143
	private void ajouterListeners() {
144
 
145
	}
146
 
147
	/**
148
	 * Méthode héritée de l'interface rafraichissable
149
	 */
150
	public void rafraichir(Object nouvelleDonnees,
151
			boolean repandreRaffraichissement) {
152
 
153
		// si on a reçu un arbre
154
		if (nouvelleDonnees instanceof Tree) {
155
			Tree nouvelArbre = (Tree) nouvelleDonnees;
156
 
157
			// on vide tous les noeuds
158
			arbreLocalites.getRootNode().eachChild(new NodeTraversalCallback() {
159
 
160
				public boolean execute(Node node) {
161
 
162
					node.remove();
163
					return true;
164
				}
165
 
166
			});
167
 
168
			// et on recopie le nouvel arbre
169
			copierFilsNoeud(nouvelArbre.getRootNode(), arbreLocalites
170
					.getRootNode());
171
 
172
			// si l'arbre n'était pas encore considéré comme instancié
173
			if (!estInstancie) {
174
				// on signale que oui
175
				estInstancie = true;
176
			}
177
 
178
			// l'état du filtre est réinitialisé
179
			filtreModifie = false;
180
 
181
			show();
182
		}
183
 
184
		if (nouvelleDonnees instanceof TreeNode) {
185
			TreeNode nd = (TreeNode) nouvelleDonnees;
186
 
187
			// si le noeud n'existe pas déjà c'est un ajout
188
			if (arbreLocalites.getTree().getNodeById(nd.getId() + "_filtre") == null) {
189
				// donc on ne fait rien de spécial
190
			}
191
			// si le noeud existe déjà c'est un déplacement
192
			else {
193
				// alors on supprime d'abord le noeud concerné
194
				arbreLocalites.getTree().getNodeById(nd.getId() + "_filtre")
195
				.remove();
196
			}
197
 
198
			// on cherche le père du nouveau noeud
199
			Node ndPereOriginal = nd.getParentNode();
200
			String idPereFiltre = ndPereOriginal.getId() + "_filtre";
201
 
202
			String[] usObj = (String[]) nd.getUserObject();
203
			TreeNode child = new TreeNode(usObj[0]);
204
			child.setId(usObj[1] + "_filtre");
205
			child.setChecked(false);
206
			child.setUserObject(usObj);
207
			arbreLocalites.getNodeById(idPereFiltre).appendChild(child);
208
 
209
			// et on ajoute le nouveau noeud à son père
210
			copierFilsNoeud(nd, child);
211
		}
212
 
213
		// si on reçoit une string
214
		if (nouvelleDonnees instanceof String) {
215
			String idSupp = (String) nouvelleDonnees + "_filtre";
216
			// c'est une suppression et si le noeud existe bien
217
			if (arbreLocalites.getTree().getNodeById(idSupp) != null) {
218
				// on le supprime
219
				arbreLocalites.getTree().getNodeById(idSupp).remove();
220
			}
221
		}
222
 
223
	}
224
 
225
 
226
	/**
227
	 * Accesseur pour le panneau contenant l'arbre
228
	 *
229
	 * @return le panneau de l'arbre des mots clés
230
	 */
231
	public TreePanel getArbreMotsCles() {
232
		return arbreLocalites;
233
	}
234
 
235
	/**
236
	 * Méthode héritée de Filtrable renvoie le nom du filtre
237
	 */
238
	public String renvoyerNomFiltre() {
239
 
240
		return "Localités";
241
	}
242
 
243
	/**
244
	 * Renvoie un tableau contenant le nom du champ à filtrer et la valeur
245
	 *
246
	 * @return un tableau contenant le nom du champ à filtrer et sa valeur
247
	 */
248
	public String[] renvoyerValeursAFiltrer() {
249
 
250
		valider();
251
 
252
		String[] valeursFiltrees = { "localites", localitesEncours };
253
 
254
		return valeursFiltrees;
255
	}
256
 
257
	/**
258
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
259
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
260
	 *
261
	 * @param ndPereOriginal
262
	 *            le père des noeuds de l'arbre original
263
	 * @param ndPereCopie
264
	 *            le père qui va recevoir les copies
265
	 */
266
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
267
		if (ndPereCopie != null && ndPereOriginal != null) {
268
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
269
 
270
			for (int i = 0; i < ndNodeFils.length; i++) {
271
 
272
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
273
				TreeNode child = new TreeNode(usObj[0]);
274
				child.setId(usObj[1] + "_filtre");
275
				child.setChecked(false);
276
				child.setUserObject(usObj);
277
				ndPereCopie.appendChild(child);
278
 
279
				if (!ndNodeFils[i].isLeaf()) {
280
					copierFilsNoeud(ndNodeFils[i], child);
281
				}
282
 
283
			}
284
		}
285
	}
286
 
287
	/**
288
	 * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non)
289
	 */
290
	public boolean renvoyerEtatFiltre() {
291
 
292
		return filtreModifie;
293
	}
294
 
295
	public void valider() {
296
		if (estInstancie) {
297
			// on vide les mots clés en cours
298
			localitesEncours = "";
299
			// pour chaque noeud à partir de la racine
300
			getArbreMotsCles().getRootNode().cascade(
301
					new NodeTraversalCallback() {
302
 
303
						// on éxécute une fonction
304
						public boolean execute(Node node) {
305
 
306
							// on récupère le mot clé associé au noeud et ses
307
							// infos
308
							TreeNode tn = getArbreMotsCles().getNodeById(
309
									node.getId());
310
 
311
							String[] usObject = (String[]) tn.getUserObject();
312
							//observationMediateur.mettreAjourLocalites(usObject[0],
313
								//	usObject[1]);
314
 
315
							if (tn.getUI().isChecked()) {
316
								// et les concatène à la string des mots clés en
317
								// cours
318
								localitesEncours += usObject[1] + ",";
319
							}
320
 
321
							return true;
322
						}
323
 
324
					});
325
 
326
			// on suppose que le filtre a change
327
			filtreModifie = true;
328
		}
329
	}
330
 
331
}