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