Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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