Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
199 david 1
package org.tela_botanica.client.vues.observation.filtres;
318 aurelien 2
import org.tela_botanica.client.interfaces.Filtrable;
155 aurelien 3
import org.tela_botanica.client.interfaces.Rafraichissable;
4
import org.tela_botanica.client.observation.ObservationMediateur;
2042 aurelien 5
import org.tela_botanica.client.util.MotsClesUtilitaire;
6
 
155 aurelien 7
import com.google.gwt.user.client.Window;
8
import com.gwtext.client.core.EventObject;
9
import com.gwtext.client.data.Node;
10
import com.gwtext.client.data.NodeTraversalCallback;
11
import com.gwtext.client.data.Tree;
318 aurelien 12
import com.gwtext.client.dd.DragData;
13
import com.gwtext.client.dd.DragDrop;
14
import com.gwtext.client.dd.DropTargetConfig;
155 aurelien 15
import com.gwtext.client.widgets.Button;
318 aurelien 16
import com.gwtext.client.widgets.Component;
155 aurelien 17
import com.gwtext.client.widgets.Panel;
18
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
318 aurelien 19
import com.gwtext.client.widgets.event.PanelListenerAdapter;
155 aurelien 20
import com.gwtext.client.widgets.form.TextField;
21
import com.gwtext.client.widgets.layout.VerticalLayout;
339 aurelien 22
import com.gwtext.client.widgets.menu.BaseItem;
23
import com.gwtext.client.widgets.menu.Item;
24
import com.gwtext.client.widgets.menu.Menu;
25
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
318 aurelien 26
import com.gwtext.client.widgets.tree.DropNodeCallback;
27
import com.gwtext.client.widgets.tree.MultiSelectionModel;
28
import com.gwtext.client.widgets.tree.TreeDragData;
155 aurelien 29
import com.gwtext.client.widgets.tree.TreeEditor;
30
import com.gwtext.client.widgets.tree.TreeNode;
31
import com.gwtext.client.widgets.tree.TreePanel;
32
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
33
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
34
 
318 aurelien 35
public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable, Filtrable {
155 aurelien 36
 
37
		/**
38
		 * Le médiateur associé à la vue
39
		 */
40
		private ObservationMediateur oMediateur = null;
41
 
42
		/**
43
		 * Le treepanel qui affiche l'arbre
44
		 */
45
		private static TreePanel arbreMotsCles = null;
46
		/**
47
		 * L'éditeur qui permet de modifier les mots clés dans l'arbre
48
		 */
49
		private TreeEditor te = null;
50
		/**
51
		 * Le textfield associé à l'éditeur
52
		 */
53
		private TextField tfEdit = null;
54
		/**
55
		 * Bouton de validation
56
		 */
318 aurelien 57
		private Button ajouterMotCle = null;
155 aurelien 58
		/**
59
		 * Une string permettant connaitre les mots clés cochés en cours séparés par
60
		 * des virgules
61
		 */
62
		private String motsClesEnCours = "";
63
		/**
64
		 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
65
		 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
66
		 * du conteneur n'ai été effectué)
67
		 */
68
		private String[] motsClesEnAttente = new String[0];
69
		/**
70
		 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
71
		 * noeud
72
		 */
73
		private boolean ajoutNoeud = false;
74
		/**
75
		 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
76
		 * noeud
77
		 */
78
		private boolean modifNoeud = false;
79
		/**
80
		 * Booléen d'instanciation du conteneur
81
		 */
82
		private boolean arbreCharge = false;
318 aurelien 83
 
155 aurelien 84
		/**
318 aurelien 85
		 * Booléen nécessaire pour l'affichage
86
		 *
87
		 */
88
		private boolean estInstancie = false;
89
 
90
		/**
155 aurelien 91
		 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
92
		 */
93
		private boolean motsCleInitialises;
318 aurelien 94
 
95
		private Component livue = null;
335 aurelien 96
 
97
		MultiSelectionModel msModel = null;
155 aurelien 98
 
2042 aurelien 99
		private String cheminTemporaireAjout = null;
100
 
155 aurelien 101
		/**
102
		 * Constructeur sans paramètre (privé car interdit d'utilisation)
103
		 */
104
		@SuppressWarnings("unused")
195 david 105
		private ArbreMotsClesObservationVue() {
155 aurelien 106
			super();
107
		}
108
 
109
		/**
110
		 * Constructeur avec paramètre
111
		 *
112
		 * @param im
113
		 *            le médiateur à associer
114
		 */
195 david 115
		public ArbreMotsClesObservationVue(ObservationMediateur om) {
155 aurelien 116
			// on crée le panel
339 aurelien 117
			super("Projets");
318 aurelien 118
 
155 aurelien 119
			this.setLayout(new VerticalLayout());
120
			oMediateur = om;
318 aurelien 121
 
122
			setBorder(false);
123
			setCollapsible(true);
124
			setTitleCollapse(true);
355 aurelien 125
			setAutoScroll(true);
155 aurelien 126
 
318 aurelien 127
			// on ajoute les listeners
128
			ajouterListenersPanel();
155 aurelien 129
 
318 aurelien 130
		}
131
 
132
		/**
133
		 * Ajoute les listeners pour le rendu du panel
134
		 */
135
		private void ajouterListenersPanel() {
136
			  this.addListener(new PanelListenerAdapter() {
155 aurelien 137
 
318 aurelien 138
				// on instancie réellement les composants au moment du rendu pour
139
				// accélérer l'affichage
140
				// et éviter des bugs
1292 aurelien 141
				@Override
318 aurelien 142
				public void onRender(Component component) {
143
 
144
					livue = oMediateur.getListeObservation();
145
 
146
					// on crée le conteneur de l'arbre
147
					arbreMotsCles = new TreePanel();
148
					// on permet le drag and drop dans l'arbre
149
					//arbreMotsCles.setEnableDD(true);
150
					arbreMotsCles.setId("x-view-tree-keyword-obs");
151
 
152
 
335 aurelien 153
					msModel = new MultiSelectionModel();
318 aurelien 154
					arbreMotsCles.setSelectionModel(msModel);
155 aurelien 155
 
318 aurelien 156
					// on crée une racine pour l'arbre
339 aurelien 157
					TreeNode root = new TreeNode("Projets");
318 aurelien 158
					root.setId("racine_obs");
339 aurelien 159
					String[] usObject = { "Projets", "racine_obs" };
318 aurelien 160
					root.setUserObject(usObject);
161
					root.setExpandable(true);
162
 
163
					arbreMotsCles.setRootNode(root);
164
 
165
					// on crée l'éditeur pour l'arbre
166
					tfEdit = new TextField();
167
					te = new TreeEditor(arbreMotsCles, tfEdit);
339 aurelien 168
					ajouterMotCle = new Button("Ajouter un projet");
318 aurelien 169
					arbreMotsCles.add(te);
170
 
171
					arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
1292 aurelien 172
						@Override
318 aurelien 173
						public void onClick(Node node, EventObject e) {
174
							if(!arbreCharge) {
175
								expand();
176
							}
177
						}
155 aurelien 178
 
1292 aurelien 179
						@Override
318 aurelien 180
						public void onExpand(Node node) {
181
							if(!arbreCharge) {
182
								obtenirArbreMotsCles();
183
								arbreCharge = true;
184
							}
185
						}
186
					});
155 aurelien 187
 
318 aurelien 188
					// on interdit le drag and drop dans l'arbre
189
					arbreMotsCles.setRootVisible(true);
190
					arbreMotsCles.setBorder(false);
191
 
192
					// on met en forme le layout
193
					add(arbreMotsCles);
194
					add(ajouterMotCle);
155 aurelien 195
 
318 aurelien 196
					// enfin on considère le composant comme instancié
197
					estInstancie = true;
198
 
199
					configDragAndDrop();
200
 
201
					// on ajoute les listeners d'évenements
202
					ajouterListeners();
203
				}
204
 
205
			});
155 aurelien 206
		}
207
 
208
		/**
209
		 * Acesseur pour le médiateur
210
		 *
211
		 * @return le médiateur associé à la vue
212
		 */
213
		private ObservationMediateur getOMediateur() {
214
 
215
			return oMediateur;
216
 
217
		}
218
 
219
		/**
220
		 * Acesseur pour l'arbre des mots clés
221
		 *
222
		 * @return le panel contenant l'arbre
223
		 */
224
		public TreePanel getArbreMotsCles() {
225
			return arbreMotsCles;
226
		}
227
 
228
		/**
229
		 * Accesseur pour l'éditeur
230
		 *
231
		 * @return l'éditeur associé à l'arbre
232
		 */
233
		public TreeEditor getTe() {
234
			return te;
235
		}
236
 
237
		/**
238
		 * Acesseur pour le TextField associé à l'éditeur
239
		 *
240
		 * @return le champ texte associé à l'éditeur
241
		 */
242
		public TextField getTfEdit() {
243
			return tfEdit;
244
		}
245
 
246
		/**
247
		 * Ajoute les listeners nécessaires pour la gestion des évènements
248
		 */
249
		private void ajouterListeners() {
2042 aurelien 250
 
251
			final Rafraichissable r = this;
155 aurelien 252
			arbreMotsCles.addListener(new TreePanelListenerAdapter() {
253
 
254
				// gestion du clic sur un noeud
1292 aurelien 255
				@Override
155 aurelien 256
				public void onClick(TreeNode node, EventObject e) {
257
 
258
					e.stopEvent();
318 aurelien 259
					boolean multi = false;
260
					if(e.hasModifier()) {
261
						multi = true;
262
					}
263
					gererClicNoeud(node,multi);
155 aurelien 264
				}
265
 
266
				// gestion du clic droit sur un noeud
1292 aurelien 267
				@Override
155 aurelien 268
				public void onContextMenu(TreeNode node, EventObject e) {
269
 
270
					e.stopEvent();
339 aurelien 271
					montrerContextMenuArbre(node, e, getTe());
155 aurelien 272
 
273
				}
274
 
275
				// gestion du double clic sur un noeud
1292 aurelien 276
				@Override
155 aurelien 277
				public void onDblClick(TreeNode node, EventObject e) {
278
 
279
					modifNoeud = true;
280
					if (!node.getId().equals("racine_obs")) {
281
						te.startEdit(node);
282
					}
283
				}
284
 
285
				// gestion de la modification du texte d'un noeud
1292 aurelien 286
				@Override
155 aurelien 287
				public void onTextChange(TreeNode node, String text, String oldText) {
288
 
289
					// on récupère les informations associées au noeud
290
					TreeNode nd = node;
291
					String[] usObject = new String[2];
292
					usObject[0] = text;
293
					usObject[1] = ((String[]) nd.getUserObject())[1];
294
					nd.setUserObject(usObject);
295
 
296
					// si c'est un nouveau noeud
297
					if (ajoutNoeud) {
298
						// on notifie le médiateur de l'ajout et on lui passe
299
						// l'arbre
300
						getOMediateur().ajouterMotCleDansArbre(nd,
2042 aurelien 301
								getArbreMotsCles().getTree(), r);
155 aurelien 302
						// et considère l'ajout achevé
303
						ajoutNoeud = false;
304
					}
305
					// si c'est noeud déjà existant
306
					else {
307
						if (modifNoeud) {
308
							// on notifie le médiateur de la modification et on lui
309
							// passe l'arbre
310
							getOMediateur().modifierMotCleDansArbre(nd,
311
									getArbreMotsCles().getTree());
312
							// et on considère la modification achevée
313
							modifNoeud = false;
314
						}
315
					}
2042 aurelien 316
					arbreMotsCles.disable();
155 aurelien 317
				}
318
 
319
				// gestion du déplacement d'un noeud
1292 aurelien 320
				@Override
155 aurelien 321
				public void onMoveNode(Tree tree, TreeNode node,
322
						TreeNode oldParent, TreeNode newParent, int index) {
323
					// on notifie le médiateur et on lui passe l'arbre
324
					getOMediateur().deplacerMotCleDansArbre(node,
325
							getArbreMotsCles().getTree());
326
				}
318 aurelien 327
 
1292 aurelien 328
				@Override
318 aurelien 329
				public boolean doBeforeNodeDrop(TreePanel treePanel,
330
						TreeNode target, DragData dragData,
331
						String point, DragDrop source,
332
						TreeNode dropNode,
333
						DropNodeCallback dropNodeCallback) {
334
 
339 aurelien 335
					if(dragData instanceof TreeDragData) {
336
						return true;
337
					}
318 aurelien 338
 
339 aurelien 339
					String idMotCle = ((String[])target.getUserObject())[1];
340
 
341
					if(oMediateur.gererDDObsSurMotCle(target, dragData)) {
318 aurelien 342
 
339 aurelien 343
						cocherMotCle(idMotCle);
344
						return true;
345
					}
346
 
347
					return false;
318 aurelien 348
				}
155 aurelien 349
 
318 aurelien 350
 
1292 aurelien 351
				@Override
318 aurelien 352
				public void onNodeDrop(TreePanel treePanel,
353
						TreeNode target, DragData dragData,
354
						String point, DragDrop source, TreeNode dropNode) {
339 aurelien 355
 
318 aurelien 356
 
357
				}
358
 
155 aurelien 359
			});
360
 
361
			// gestion de la validation
318 aurelien 362
			ajouterMotCle.addListener(new ButtonListenerAdapter() {
155 aurelien 363
 
364
				// lors du clic
1292 aurelien 365
				@Override
155 aurelien 366
				public void onClick(Button button, EventObject e) {
318 aurelien 367
 
339 aurelien 368
					TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
369
					TreeNode noeudAjout;
370
					if(noeuds.length > 0) {
371
						noeudAjout = noeuds[noeuds.length - 1];
372
					} else {
373
						noeudAjout = arbreMotsCles.getRootNode();
374
					}
375
 
376
					ajouterNoeud(noeudAjout);
318 aurelien 377
 
155 aurelien 378
				}
379
			});
380
 
381
		}
318 aurelien 382
 
383
 
384
		/**
385
		 * Configure le drag 'n drop pour la liste
386
		 */
387
		private void configDragAndDrop()
388
		{
389
			// on fabrique la nouvelle configuration
390
			// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
391
			arbreMotsCles.setDdGroup("ObsMotsClesGroup");
392
			//arbreMotsCles.setEnableDD(true);
393
			arbreMotsCles.setEnableDrag(true);
394
			arbreMotsCles.setEnableDrop(true);
395
			DropTargetConfig dtc = new DropTargetConfig();
396
			dtc.setdDdGroup("ObsMotsClesGroup");
397
		}
398
 
155 aurelien 399
		/**
400
		 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
401
		 */
402
		public void obtenirArbreMotsCles() {
403
 
404
			getOMediateur().obtenirArbreMotsCles(this);
405
 
406
		}
407
 
408
		/**
409
		 * Supprime un noeud de l'arbre
410
		 *
411
		 * @param n
412
		 *            le noeud à supprimer
413
		 */
414
		public void supprimerNoeud(TreeNode n) {
415
			// si ça n'est pas la racine (qu'on ne peut pas supprimer)
416
			if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
339 aurelien 417
 
418
				if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) {
419
					// on détache le noeud et on le détruit
420
					n.getParentNode().removeChild(n);
421
					n.destroy();
422
					// puis on en notifie le médiateur en lui passant le noeud supprimé
423
					// et l'arbre
424
					getOMediateur()
425
							.supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
426
				}
155 aurelien 427
			} else {
428
				// si l'utilisateur tente de supprimer la racine, on l'avertit de
429
				// son erreur
430
				Window.alert("Impossible de supprimer la racine de l'arbre");
431
			}
432
		}
433
 
434
		/**
435
		 * Ajoute un noeud dans l'arbre au parent donné
436
		 *
437
		 * @param parent
438
		 *            le futur parent du noeud à ajouter
439
		 */
440
		public void ajouterNoeud(TreeNode parent) {
441
 
442
			// on met l'ajout du noeud à vrai
443
			ajoutNoeud = true;
444
			// on crée un nouveau noeud vide
445
			TreeNode nd = new TreeNode("");
446
			nd.setCls("x-view-treenode-keyword");
447
			// on associe un objet au noeud qui contient des infos
448
			String[] usObject = new String[2];
449
			// l'objet contient le nom du noeud
450
			usObject[0] = "";
2042 aurelien 451
			usObject[1] = "";
452
 
155 aurelien 453
			nd.setUserObject(usObject);
454
			// l'identifiant d'un noeud c'est son hashcode
455
			// l'objet associé au noeud contient aussi son identifiant
456
 
457
			// on le concatène au parent et on étend ses enfants
458
			parent.appendChild(nd);
2042 aurelien 459
			// en attendant qu'il soit ajouté on lui affecte son chemin en tant qu'id
460
			// ce qui permettra de le retrouver et de lui affecter son id sur retour du web service
461
			cheminTemporaireAjout  = MotsClesUtilitaire.construireChemin(nd);
462
			nd.setId(cheminTemporaireAjout);
155 aurelien 463
			parent.expand();
464
			// enfin on place le curseur et on fait apparaitre le champ d'édition
465
			// pour que l'utilisateur nomme son mot clé
466
			te.startEdit(nd);
467
		}
2042 aurelien 468
 
155 aurelien 469
		/**
318 aurelien 470
		 * Fonction de gestion sur le clic sur le noeud
155 aurelien 471
		 *
472
		 * @param node
473
		 */
318 aurelien 474
		public void gererClicNoeud(TreeNode node, boolean multi) {
475
 
339 aurelien 476
			if(!arbreCharge) {
477
				obtenirArbreMotsCles();
478
			} else {
479
				if(multi) {
480
				}
481
				((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi);
482
				oMediateur.obtenirNombreObservation();
483
			}
155 aurelien 484
		}
485
 
486
		/**
487
		 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
488
		 * clés à cocher
489
		 *
490
		 * @param motsClesIds
491
		 *            un tableau contenant les identifiants des mots clés à cocher
492
		 */
493
		public void cocherMotsCles(final String[] motsClesIds) {
494
			if (getArbreMotsCles() != null
495
					&& getArbreMotsCles().getRootNode() != null) {
496
				// à partir de la racine
497
				getArbreMotsCles().getRootNode().cascade(
498
						new NodeTraversalCallback() {
499
 
500
							// pour chaque noeud
1292 aurelien 501
							@Override
155 aurelien 502
							public boolean execute(Node node) {
503
 
504
								// on parcourt le tableau des mots clés
505
								for (int i = 0; i < motsClesIds.length; i++) {
506
									// si le mot clé fait partie des id à cocher on
507
									// le coche
508
									String usObject[] = (String[]) node
509
											.getUserObject();
510
									String nodeId = usObject[1];
511
 
512
									if (nodeId.equals(motsClesIds[i])) {
513
 
339 aurelien 514
										getArbreMotsCles().getNodeById(nodeId)
515
										.getUI().getTextEl().addClassName("x-tree-node-text-kw");
516
 
155 aurelien 517
											return true;
518
									}
519
								}
339 aurelien 520
 
521
								if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) {
522
									getArbreMotsCles().getNodeById(node.getId())
523
									.getUI().getTextEl().removeClassName("x-tree-node-text-kw");
524
								}
525
 
526
 
155 aurelien 527
								// et on passe au suivant
528
								return true;
529
							}
530
 
531
						});
532
			}
533
			else {
534
				motsClesEnAttente = motsClesIds ;
535
			}
536
		}
339 aurelien 537
 
538
		public void cocherMotCle(String motCleId) {
539
			getArbreMotsCles().getNodeById(motCleId)
540
			.getUI().getTextEl().addClassName("x-tree-node-text-kw");
541
		}
542
 
543
		public void initialiser() {
544
 
545
			arbreCharge = false ;
546
			motsClesEnCours = "";
547
			arbreMotsCles.collapseAll();
548
			// on vide l'ancien arbre
549
			Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
550
			for (int i = 0; i < rootChild.length; i++) {
551
 
552
				rootChild[i].remove();
553
			}
554
 
555
			arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
556
 
1292 aurelien 557
				@Override
339 aurelien 558
				public void onExpand(Node node) {
559
					if(!arbreCharge)
560
					{
561
						obtenirArbreMotsCles() ;
562
						arbreCharge = true ;
563
					}
564
				}
565
 
566
			}) ;
567
		}
155 aurelien 568
 
569
		/**
570
		 * Méthode héritée de l'interface rafraichissable
571
		 *
572
		 * @param nouvelleDonnees
573
		 *            les nouvelles données pour l'objet
574
		 * @param repandreRafraichissement
575
		 *            booleen qui dit si on doit répandre l'évenement
576
		 */
1292 aurelien 577
		@Override
155 aurelien 578
		public void rafraichir(Object nouvelleDonnees,
579
				boolean repandreRafraichissement) {
580
 
581
			if(nouvelleDonnees instanceof Tree) {
582
 
583
				Tree nouvelArbre = (Tree)nouvelleDonnees ;
584
 
585
				// on prend sa racine et on l'attache à l'arbre des mots clés
586
				Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
587
				for (int i = 0; i < rootChild.length; i++) {
588
 
589
					rootChild[i].remove();
590
				}
591
 
2042 aurelien 592
				MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
155 aurelien 593
 
594
				// si l'arbre n'était pas encore considéré comme instancié
595
				if (!arbreCharge) {
596
					// on signale que oui
597
					arbreCharge = true;
598
				}
599
 
339 aurelien 600
 
155 aurelien 601
				// s'il y a des mots clés en attente (lors du premier rendering)
602
				if (motsCleInitialises == false && motsClesEnAttente != null) {
603
					// on les coche
339 aurelien 604
					cocherMotsCles(motsClesEnAttente) ;
155 aurelien 605
					motsCleInitialises = true;
606
				}
607
 
608
				if(motsClesEnAttente.length > 0) {
339 aurelien 609
					cocherMotsCles(motsClesEnAttente);
610
				}
155 aurelien 611
			}
612
 
613
			// Si on reçoit un tableau de String (cas ou l'on séléectionne une
318 aurelien 614
			// nouvelle obs)
339 aurelien 615
			if (nouvelleDonnees instanceof String) {
616
 
617
				String chaineMc = (String)nouvelleDonnees;
618
				String[] motsClesIds = chaineMc.split(";");
619
 
155 aurelien 620
				// et que l'arbre est instancié
621
				if (arbreCharge) {
622
					// le tableau de String contient les id des mots clés associés à
623
					// l'image
624
					// on coche les mots clés contenu dans le tableau
625
					cocherMotsCles(motsClesIds);
626
 
627
				}
628
				// si l'arbre n'est pas encore instancié on met les mots clés en
629
				// attente
630
				else {
1292 aurelien 631
					motsClesEnAttente = motsClesIds;
155 aurelien 632
				}
633
			}
339 aurelien 634
 
2042 aurelien 635
			// reception d'un nouvel identifiant de mot clé
636
			if(nouvelleDonnees instanceof Integer) {
637
				if(cheminTemporaireAjout != null) {
638
					String id = ((Integer)(nouvelleDonnees)).toString();
639
					TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
640
					String[] userObj = {noeudEnAjout.getText(), id};
641
					noeudEnAjout.setUserObject(userObj);
642
					noeudEnAjout.setId(id);
643
					cheminTemporaireAjout = null;
155 aurelien 644
				}
645
			}
2042 aurelien 646
 
647
			arbreMotsCles.enable();
155 aurelien 648
		}
318 aurelien 649
 
650
		public void raz() {
651
 
339 aurelien 652
			arbreCharge = false ;
653
			arbreMotsCles.collapseAll();
654
			arbreMotsCles.clear() ;
655
 
656
			// on crée une racine pour l'arbre
657
			TreeNode root = new TreeNode("Projets");
658
			root.setId("racine_obs");
659
			String[] usObject = { "Projets", "racine_obs" };
660
			root.setUserObject(usObject);
661
			root.setExpandable(true);
662
 
663
			arbreMotsCles.setRootNode(root);
664
 
665
			arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
666
 
1292 aurelien 667
				@Override
339 aurelien 668
				public void onExpand(Node node) {
669
					if(!arbreCharge)
670
					{
671
						obtenirArbreMotsCles() ;
672
						arbreCharge = true ;
673
					}
674
				}
675
 
676
			}) ;
677
 
678
			motsClesEnCours  = "";
318 aurelien 679
		}
680
 
1292 aurelien 681
		@Override
318 aurelien 682
		public boolean renvoyerEtatFiltre() {
683
			// TODO Auto-generated method stub
684
			return false;
685
		}
686
 
1292 aurelien 687
		@Override
318 aurelien 688
		public String renvoyerNomFiltre() {
689
			// TODO Auto-generated method stub
690
			return null;
691
		}
692
 
1292 aurelien 693
		@Override
318 aurelien 694
		public String[] renvoyerValeursAFiltrer() {
335 aurelien 695
 
339 aurelien 696
			String val = "";
335 aurelien 697
 
339 aurelien 698
			TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
699
 
700
			for(int i = 0; i< noeuds.length ; i++) {
701
				if(noeuds[i].getDepth() > 0) {
702
					val += ";"+noeuds[i].getId();
703
				}
704
			}
705
 
706
			val = val.replaceFirst(";", "");
707
 
965 aurelien 708
			String[] valeursFiltres = {"id_mots_cles", val};
335 aurelien 709
 
710
			return valeursFiltres;
318 aurelien 711
		}
712
 
1292 aurelien 713
		@Override
318 aurelien 714
		public void valider() {
715
			// TODO Auto-generated method stub
716
 
717
		}
339 aurelien 718
 
719
 
720
		public void montrerContextMenuArbre(final TreeNode n, EventObject e,
721
				TreeEditor te) {
722
				Menu mn = new Menu();
723
				final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
724
						"Ajouter un projet");
725
				final com.gwtext.client.widgets.menu.Item suppN = new Item(
726
						"Supprimer projet");
727
 
728
				mn.addItem(ajoutN);
729
				mn.addItem(suppN);
730
 
731
				mn.addListener(new MenuListenerAdapter() {
732
 
1292 aurelien 733
					@Override
339 aurelien 734
					public void onItemClick(BaseItem item, EventObject e) {
735
						if (item.equals(suppN)) {
736
							supprimerNoeud(n);
737
						}
738
						if (item.equals(ajoutN)) {
739
							ajouterNoeud(n);
740
						}
741
					}
742
				});
743
 
744
				mn.showAt(e.getXY());
745
		}
683 aurelien 746
 
1292 aurelien 747
		@Override
683 aurelien 748
		public void viderFiltre() {
749
			arbreMotsCles.getSelectionModel().clearSelections();
750
			motsClesEnCours = "";
751
		}
155 aurelien 752
}