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