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