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