Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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