Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | 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.Rafraichissable;
5
 
6
import com.google.gwt.user.client.Window;
7
import com.gwtext.client.core.EventObject;
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.Button;
12
import com.gwtext.client.widgets.Panel;
13
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
14
import com.gwtext.client.widgets.form.TextField;
15
import com.gwtext.client.widgets.layout.VerticalLayout;
16
import com.gwtext.client.widgets.tree.TreeEditor;
17
import com.gwtext.client.widgets.tree.TreeNode;
18
import com.gwtext.client.widgets.tree.TreePanel;
19
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
20
 
21
/**
5 aperonnet 22
 * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
23
 * clés cochables et réorganisables à volonté
24
 *
2 aperonnet 25
 * @author aurelien
5 aperonnet 26
 *
2 aperonnet 27
 */
28
public class ArbreMotsClesVue extends Panel implements Rafraichissable {
29
 
30
	/**
31
	 * Le médiateur associé à la vue
32
	 */
5 aperonnet 33
	private ImageMediateur iMediateur = null;
34
 
2 aperonnet 35
	/**
36
	 * Le treepanel qui affiche l'arbre
37
	 */
5 aperonnet 38
	private TreePanel arbreMotsCles = null;
2 aperonnet 39
	/**
40
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
41
	 */
5 aperonnet 42
	private TreeEditor te = null;
2 aperonnet 43
	/**
44
	 * Le textfield associé à l'éditeur
45
	 */
5 aperonnet 46
	private TextField tfEdit = null;
2 aperonnet 47
	/**
48
	 * Bouton de validation
49
	 */
5 aperonnet 50
	private Button valider = null;
2 aperonnet 51
	/**
5 aperonnet 52
	 * Une string permettant connaitre les mots clés cochés en cours séparés par
53
	 * des virgules
2 aperonnet 54
	 */
5 aperonnet 55
	private String motsClesEnCours = "";
1009 aurelien 56
 
57
	private String[] tableauMotsClesEnCours = new String[0];
2 aperonnet 58
	/**
5 aperonnet 59
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
60
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
61
	 * du conteneur n'ai été effectué)
2 aperonnet 62
	 */
155 aurelien 63
	private String[] motsClesEnAttente = new String[0];
2 aperonnet 64
	/**
5 aperonnet 65
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
66
	 * noeud
2 aperonnet 67
	 */
5 aperonnet 68
	private boolean ajoutNoeud = false;
2 aperonnet 69
	/**
5 aperonnet 70
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
71
	 * noeud
2 aperonnet 72
	 */
5 aperonnet 73
	private boolean modifNoeud = false;
2 aperonnet 74
	/**
75
	 * Booléen d'instanciation du conteneur
76
	 */
135 aurelien 77
	private boolean arbreCharge = false;
2 aperonnet 78
	/**
79
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
80
	 */
5 aperonnet 81
	private boolean motsCleInitialises;
82
 
2 aperonnet 83
	/**
84
	 * Constructeur sans paramètre (privé car interdit d'utilisation)
85
	 */
86
	@SuppressWarnings("unused")
5 aperonnet 87
	private ArbreMotsClesVue() {
88
		super();
2 aperonnet 89
	}
5 aperonnet 90
 
2 aperonnet 91
	/**
92
	 * Constructeur avec paramètre
5 aperonnet 93
	 *
94
	 * @param im
95
	 *            le médiateur à associer
2 aperonnet 96
	 */
5 aperonnet 97
	public ArbreMotsClesVue(ImageMediateur im) {
2 aperonnet 98
		// on crée le panel
5 aperonnet 99
		super("Mots clés");
2 aperonnet 100
		this.setLayout(new VerticalLayout());
5 aperonnet 101
		iMediateur = im;
102
 
2 aperonnet 103
		// on crée le conteneur de l'arbre
5 aperonnet 104
		arbreMotsCles = new TreePanel();
2 aperonnet 105
		// on permet le drag and drop dans l'arbre
5 aperonnet 106
		arbreMotsCles.setEnableDD(true);
107
		arbreMotsCles.setId("x-view-tree-keyword");
108
 
2 aperonnet 109
		// on crée une racine pour l'arbre
5 aperonnet 110
		TreeNode root = new TreeNode("Tags");
111
		root.setId("racine");
112
		String[] usObject = { "Mots clés", "racine" };
113
		root.setUserObject(usObject);
114
		arbreMotsCles.setRootNode(root);
155 aurelien 115
		arbreMotsCles.setRootVisible(true);
5 aperonnet 116
		arbreMotsCles.setBorder(false);
117
		arbreMotsCles.setWidth(500);
118
 
2 aperonnet 119
		// on crée l'éditeur pour l'arbre
5 aperonnet 120
		tfEdit = new TextField();
121
		tfEdit.setAutoWidth(true);
122
		te = new TreeEditor(arbreMotsCles, tfEdit);
123
		valider = new Button("Appliquer");
124
		arbreMotsCles.add(te);
125
 
2 aperonnet 126
		// on met en forme le layout
5 aperonnet 127
		this.add(arbreMotsCles);
128
		this.add(valider);
129
 
130
		this.setBorder(false);
131
		this.setCollapsible(true);
132
		this.setTitleCollapse(true);
135 aurelien 133
 
2 aperonnet 134
		// on ajoute les listeners
5 aperonnet 135
		ajouterListeners();
136
 
2 aperonnet 137
	}
5 aperonnet 138
 
2 aperonnet 139
	/**
140
	 * Acesseur pour le médiateur
5 aperonnet 141
	 *
2 aperonnet 142
	 * @return le médiateur associé à la vue
143
	 */
135 aurelien 144
	private ImageMediateur getIMediateur() {
5 aperonnet 145
 
146
		return iMediateur;
147
 
2 aperonnet 148
	}
5 aperonnet 149
 
2 aperonnet 150
	/**
151
	 * Acesseur pour l'arbre des mots clés
5 aperonnet 152
	 *
2 aperonnet 153
	 * @return le panel contenant l'arbre
154
	 */
155
	public TreePanel getArbreMotsCles() {
156
		return arbreMotsCles;
157
	}
158
 
159
	/**
160
	 * Accesseur pour l'éditeur
5 aperonnet 161
	 *
2 aperonnet 162
	 * @return l'éditeur associé à l'arbre
163
	 */
164
	public TreeEditor getTe() {
165
		return te;
166
	}
167
 
168
	/**
169
	 * Acesseur pour le TextField associé à l'éditeur
5 aperonnet 170
	 *
2 aperonnet 171
	 * @return le champ texte associé à l'éditeur
172
	 */
173
	public TextField getTfEdit() {
174
		return tfEdit;
175
	}
5 aperonnet 176
 
2 aperonnet 177
	/**
178
	 * Ajoute les listeners nécessaires pour la gestion des évènements
179
	 */
5 aperonnet 180
	private void ajouterListeners() {
2 aperonnet 181
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
5 aperonnet 182
 
1009 aurelien 183
			public void onExpandNode(TreeNode node) {
184
				cocherMotsCles(tableauMotsClesEnCours);
185
			}
186
 
2 aperonnet 187
			// gestion du clic sur un noeud
188
			public void onClick(TreeNode node, EventObject e) {
5 aperonnet 189
 
190
				e.stopEvent();
2 aperonnet 191
				gererClicNoeud(node);
192
			}
193
 
194
			// gestion du clic droit sur un noeud
195
			public void onContextMenu(TreeNode node, EventObject e) {
5 aperonnet 196
 
197
				e.stopEvent();
135 aurelien 198
				getIMediateur().montrerContextMenuArbre(node, e, getTe());
5 aperonnet 199
 
2 aperonnet 200
			}
5 aperonnet 201
 
2 aperonnet 202
			// gestion du double clic sur un noeud
203
			public void onDblClick(TreeNode node, EventObject e) {
5 aperonnet 204
 
1009 aurelien 205
				modifNoeud = true;
5 aperonnet 206
				if (!node.getId().equals("racine")) {
2 aperonnet 207
					te.startEdit(node);
208
				}
209
			}
5 aperonnet 210
 
211
			// gestion de la modification du texte d'un noeud
2 aperonnet 212
			public void onTextChange(TreeNode node, String text, String oldText) {
213
 
214
				// on récupère les informations associées au noeud
5 aperonnet 215
				TreeNode nd = node;
216
				String[] usObject = new String[2];
217
				usObject[0] = text;
218
				usObject[1] = ((String[]) nd.getUserObject())[1];
219
				nd.setUserObject(usObject);
220
 
2 aperonnet 221
				// si c'est un nouveau noeud
5 aperonnet 222
				if (ajoutNoeud) {
1009 aurelien 223
					// on considère l'ajout achevé
1007 aurelien 224
					ajoutNoeud = false;
1009 aurelien 225
					// et on notifie le médiateur de l'ajout et on lui passe
5 aperonnet 226
					// l'arbre
135 aurelien 227
					getIMediateur().ajouterMotCleDansArbre(nd,
5 aperonnet 228
							getArbreMotsCles().getTree());
2 aperonnet 229
				}
230
				// si c'est noeud déjà existant
5 aperonnet 231
				else {
1007 aurelien 232
					// et on considère la modification achevée
233
					modifNoeud = false;
234
					// on notifie le médiateur de la modification et on lui
235
					// passe l'arbre
236
					getIMediateur().modifierMotCleDansArbre(nd,
237
							getArbreMotsCles().getTree());
2 aperonnet 238
				}
5 aperonnet 239
 
2 aperonnet 240
			}
5 aperonnet 241
 
2 aperonnet 242
			// gestion du déplacement d'un noeud
5 aperonnet 243
			public void onMoveNode(Tree tree, TreeNode node,
244
					TreeNode oldParent, TreeNode newParent, int index) {
2 aperonnet 245
				// on notifie le médiateur et on lui passe l'arbre
135 aurelien 246
				getIMediateur().deplacerMotCleDansArbre(node,
5 aperonnet 247
						getArbreMotsCles().getTree());
248
			}
249
 
250
		});
251
 
2 aperonnet 252
		// gestion de la validation
253
		valider.addListener(new ButtonListenerAdapter() {
5 aperonnet 254
 
2 aperonnet 255
			// lors du clic
256
			public void onClick(Button button, EventObject e) {
5 aperonnet 257
 
2 aperonnet 258
				// on vide les mots clés en cours
5 aperonnet 259
				motsClesEnCours = "";
2 aperonnet 260
				// pour chaque noeud à partir de la racine
5 aperonnet 261
				getArbreMotsCles().getRootNode().cascade(
262
						new NodeTraversalCallback() {
2 aperonnet 263
 
5 aperonnet 264
							// on éxécute une fonction
265
							public boolean execute(Node node) {
266
 
267
								// on récupère le mot clé associé au noeud et
268
								// ses infos
269
								TreeNode tn = getArbreMotsCles().getNodeById(
270
										node.getId());
271
 
272
								String[] usObject = (String[]) tn
273
										.getUserObject();
135 aurelien 274
								getIMediateur().mettreAjourMotsClesId(
5 aperonnet 275
										usObject[0], usObject[1]);
276
 
277
								if (tn.getUI().isChecked()) {
278
									// et les concatène à la string des mots
279
									// clés en cours
280
									motsClesEnCours += usObject[1] + ",";
281
								}
282
 
283
								return true;
284
							}
285
 
286
						});
287
 
288
				// enfin on notifie le médiateur et on lui passe l'arbre et la
289
				// liste des mots clés ainsi obtenue
135 aurelien 290
				getIMediateur().mettreAjourMotsCles(motsClesEnCours,
5 aperonnet 291
						arbreMotsCles.getTree());
2 aperonnet 292
			}
5 aperonnet 293
		});
2 aperonnet 294
	}
5 aperonnet 295
 
2 aperonnet 296
	/**
297
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
298
	 */
299
	public void obtenirArbreMotsCles() {
5 aperonnet 300
 
135 aurelien 301
		getIMediateur().obtenirArbreMotsCles(this);
5 aperonnet 302
 
2 aperonnet 303
	}
304
 
305
	/**
306
	 * Supprime un noeud de l'arbre
5 aperonnet 307
	 *
308
	 * @param n
309
	 *            le noeud à supprimer
2 aperonnet 310
	 */
5 aperonnet 311
	public void supprimerNoeud(TreeNode n) {
2 aperonnet 312
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
5 aperonnet 313
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
2 aperonnet 314
			// on détache le noeud et on le détruit
315
			n.getParentNode().removeChild(n);
5 aperonnet 316
			n.destroy();
317
			// puis on en notifie le médiateur en lui passant le noeud supprimé
318
			// et l'arbre
135 aurelien 319
			getIMediateur()
5 aperonnet 320
					.supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
321
		} else {
322
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
323
			// son erreur
324
			Window.alert("Impossible de supprimer la racine de l'arbre");
2 aperonnet 325
		}
326
	}
5 aperonnet 327
 
2 aperonnet 328
	/**
329
	 * Ajoute un noeud dans l'arbre au parent donné
5 aperonnet 330
	 *
331
	 * @param parent
332
	 *            le futur parent du noeud à ajouter
2 aperonnet 333
	 */
5 aperonnet 334
	public void ajouterNoeud(TreeNode parent) {
2 aperonnet 335
 
5 aperonnet 336
		// on met l'ajout du noeud à vrai
337
		ajoutNoeud = true;
338
		// on crée un nouveau noeud vide
339
		TreeNode nd = new TreeNode("");
340
		nd.setCls("x-view-treenode-keyword");
341
		nd.setChecked(true);
342
		// on associe un objet au noeud qui contient des infos
343
		String[] usObject = new String[2];
344
		// l'objet contient le nom du noeud
345
		usObject[0] = "";
346
		usObject[1] = genererIdMotCle(nd);
347
		nd.setId(usObject[1]);
348
		nd.setUserObject(usObject);
349
		// l'identifiant d'un noeud c'est son hashcode
350
		// l'objet associé au noeud contient aussi son identifiant
351
 
352
		// on le concatène au parent et on étend ses enfants
353
		parent.appendChild(nd);
354
		parent.expand();
355
		// enfin on place le curseur et on fait apparaitre le champ d'édition
356
		// pour que l'utilisateur nomme son mot clé
357
		te.startEdit(nd);
358
 
2 aperonnet 359
	}
5 aperonnet 360
 
2 aperonnet 361
	/**
362
	 * Coche le noeud s'il est décoché, le décoche sinon
5 aperonnet 363
	 *
2 aperonnet 364
	 * @param node
365
	 */
5 aperonnet 366
	public void gererClicNoeud(TreeNode node) {
367
		if (node.getUI().isChecked()) {
368
			node.getUI().toggleCheck(false);
369
		} else {
370
			node.getUI().toggleCheck(true);
2 aperonnet 371
		}
372
	}
5 aperonnet 373
 
2 aperonnet 374
	/**
5 aperonnet 375
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
376
	 * clés à cocher
377
	 *
378
	 * @param motsClesIds
379
	 *            un tableau contenant les identifiants des mots clés à cocher
2 aperonnet 380
	 */
5 aperonnet 381
	public void cocherMotsCles(final String[] motsClesIds) {
382
		if (getArbreMotsCles() != null
383
				&& getArbreMotsCles().getRootNode() != null) {
2 aperonnet 384
			// à partir de la racine
5 aperonnet 385
			getArbreMotsCles().getRootNode().cascade(
386
					new NodeTraversalCallback() {
387
 
388
						// pour chaque noeud
389
						public boolean execute(Node node) {
390
 
88 jpm 391
							getArbreMotsCles().getNodeById(node.getId())
392
							.getUI().toggleCheck(false);
393
 
5 aperonnet 394
							// on parcourt le tableau des mots clés
395
							for (int i = 0; i < motsClesIds.length; i++) {
396
								// si le mot clé fait partie des id à cocher on
397
								// le coche
398
								String usObject[] = (String[]) node
399
										.getUserObject();
400
								String nodeId = usObject[1];
401
 
402
								if (nodeId.equals(motsClesIds[i])) {
403
									getArbreMotsCles().getNodeById(nodeId)
404
											.getUI().toggleCheck(true);
405
									return true;
406
								}
2 aperonnet 407
							}
5 aperonnet 408
							// et on passe au suivant
409
							return true;
2 aperonnet 410
						}
5 aperonnet 411
 
412
					});
2 aperonnet 413
		}
414
	}
5 aperonnet 415
 
2 aperonnet 416
	/**
417
	 * Méthode héritée de l'interface rafraichissable
5 aperonnet 418
	 *
419
	 * @param nouvelleDonnees
420
	 *            les nouvelles données pour l'objet
421
	 * @param repandreRafraichissement
422
	 *            booleen qui dit si on doit répandre l'évenement
2 aperonnet 423
	 */
424
	public void rafraichir(Object nouvelleDonnees,
425
			boolean repandreRafraichissement) {
101 jpm 426
 
155 aurelien 427
		if(nouvelleDonnees instanceof Tree) {
5 aperonnet 428
 
155 aurelien 429
			Tree nouvelArbre = (Tree)nouvelleDonnees ;
5 aperonnet 430
 
431
			// on prend sa racine et on l'attache à l'arbre des mots clés
432
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
433
			for (int i = 0; i < rootChild.length; i++) {
135 aurelien 434
 
5 aperonnet 435
				rootChild[i].remove();
436
			}
101 jpm 437
 
155 aurelien 438
			copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
5 aperonnet 439
 
440
			// si l'arbre n'était pas encore considéré comme instancié
135 aurelien 441
			if (!arbreCharge) {
5 aperonnet 442
				// on signale que oui
135 aurelien 443
				arbreCharge = true;
5 aperonnet 444
			}
2 aperonnet 445
		}
5 aperonnet 446
 
447
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
448
		// nouvelle image)
449
		if (nouvelleDonnees instanceof String[]) {
1009 aurelien 450
 
5 aperonnet 451
				// le tableau de String contient les id des mots clés associés à
452
				// l'image
2 aperonnet 453
				// on coche les mots clés contenu dans le tableau
1009 aurelien 454
				tableauMotsClesEnCours = (String[]) nouvelleDonnees;
455
				cocherMotsCles(tableauMotsClesEnCours);
2 aperonnet 456
		}
457
	}
5 aperonnet 458
 
459
	private String genererIdMotCle(TreeNode nd) {
460
		return "" + (nd.hashCode() + (Math.random() * 10000));
2 aperonnet 461
	}
155 aurelien 462
 
463
	/**
464
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
465
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
466
	 *
467
	 * @param ndPereOriginal
468
	 *            le père des noeuds de l'arbre original
469
	 * @param ndPereCopie
470
	 *            le père qui va recevoir les copies
471
	 */
472
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
473
		if (ndPereCopie != null && ndPereOriginal != null) {
474
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
475
 
476
			for (int i = 0; i < ndNodeFils.length; i++) {
2 aperonnet 477
 
155 aurelien 478
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
479
				TreeNode child = new TreeNode(usObj[0]);
480
				child.setId(usObj[1]);
481
				child.setChecked(false);
482
				child.setUserObject(usObj);
483
				ndPereCopie.appendChild(child);
484
 
485
				if (!ndNodeFils[i].isLeaf()) {
486
					copierFilsNoeud(ndNodeFils[i], child);
487
				}
488
 
489
			}
490
		}
491
	}
2 aperonnet 492
}