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