Subversion Repositories eFlore/Applications.cel

Rev

Rev 155 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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