Subversion Repositories eFlore/Applications.cel

Rev

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

Rev Author Line No. Line
199 david 1
package org.tela_botanica.client.vues.observation.filtres;
318 aurelien 2
import org.tela_botanica.client.interfaces.Filtrable;
155 aurelien 3
import org.tela_botanica.client.interfaces.Rafraichissable;
4
import org.tela_botanica.client.observation.ObservationMediateur;
2042 aurelien 5
import org.tela_botanica.client.util.MotsClesUtilitaire;
6
 
155 aurelien 7
import com.google.gwt.user.client.Window;
8
import com.gwtext.client.core.EventObject;
9
import com.gwtext.client.data.Node;
10
import com.gwtext.client.data.NodeTraversalCallback;
11
import com.gwtext.client.data.Tree;
318 aurelien 12
import com.gwtext.client.dd.DragData;
13
import com.gwtext.client.dd.DragDrop;
14
import com.gwtext.client.dd.DropTargetConfig;
155 aurelien 15
import com.gwtext.client.widgets.Button;
318 aurelien 16
import com.gwtext.client.widgets.Component;
155 aurelien 17
import com.gwtext.client.widgets.Panel;
18
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
318 aurelien 19
import com.gwtext.client.widgets.event.PanelListenerAdapter;
155 aurelien 20
import com.gwtext.client.widgets.form.TextField;
21
import com.gwtext.client.widgets.layout.VerticalLayout;
339 aurelien 22
import com.gwtext.client.widgets.menu.BaseItem;
23
import com.gwtext.client.widgets.menu.Item;
24
import com.gwtext.client.widgets.menu.Menu;
25
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
318 aurelien 26
import com.gwtext.client.widgets.tree.DropNodeCallback;
27
import com.gwtext.client.widgets.tree.MultiSelectionModel;
28
import com.gwtext.client.widgets.tree.TreeDragData;
155 aurelien 29
import com.gwtext.client.widgets.tree.TreeEditor;
30
import com.gwtext.client.widgets.tree.TreeNode;
31
import com.gwtext.client.widgets.tree.TreePanel;
32
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
33
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
34
 
318 aurelien 35
public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable, Filtrable {
155 aurelien 36
 
37
		/**
38
		 * Le médiateur associé à la vue
39
		 */
40
		private ObservationMediateur oMediateur = null;
41
 
42
		/**
43
		 * Le treepanel qui affiche l'arbre
44
		 */
45
		private static TreePanel arbreMotsCles = null;
46
		/**
47
		 * L'éditeur qui permet de modifier les mots clés dans l'arbre
48
		 */
49
		private TreeEditor te = null;
50
		/**
51
		 * Le textfield associé à l'éditeur
52
		 */
53
		private TextField tfEdit = null;
54
		/**
55
		 * Bouton de validation
56
		 */
318 aurelien 57
		private Button ajouterMotCle = null;
155 aurelien 58
		/**
59
		 * Une string permettant connaitre les mots clés cochés en cours séparés par
60
		 * des virgules
61
		 */
62
		private String motsClesEnCours = "";
63
		/**
64
		 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
65
		 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
66
		 * du conteneur n'ai été effectué)
67
		 */
68
		private String[] motsClesEnAttente = new String[0];
69
		/**
70
		 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
71
		 * noeud
72
		 */
73
		private boolean ajoutNoeud = false;
74
		/**
75
		 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
76
		 * noeud
77
		 */
78
		private boolean modifNoeud = false;
79
		/**
80
		 * Booléen d'instanciation du conteneur
81
		 */
82
		private boolean arbreCharge = false;
318 aurelien 83
 
155 aurelien 84
		/**
318 aurelien 85
		 * Booléen nécessaire pour l'affichage
86
		 *
87
		 */
88
		private boolean estInstancie = false;
89
 
90
		/**
155 aurelien 91
		 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
92
		 */
93
		private boolean motsCleInitialises;
318 aurelien 94
 
95
		private Component livue = null;
335 aurelien 96
 
97
		MultiSelectionModel msModel = null;
155 aurelien 98
 
2042 aurelien 99
		private String cheminTemporaireAjout = null;
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
					}
2227 aurelien 294
 
295
					if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
296
						te.startEdit(node);
297
						Window.alert("Un mot clé de même nom existe déjà à cette position");
298
						return;
299
					}
155 aurelien 300
 
301
					// on récupère les informations associées au noeud
302
					TreeNode nd = node;
303
					String[] usObject = new String[2];
304
					usObject[0] = text;
305
					usObject[1] = ((String[]) nd.getUserObject())[1];
306
					nd.setUserObject(usObject);
307
 
308
					// si c'est un nouveau noeud
309
					if (ajoutNoeud) {
2062 aurelien 310
						ajouterMotCleDansArbreMediateur(nd);
155 aurelien 311
					}
312
					// si c'est noeud déjà existant
313
					else {
314
						if (modifNoeud) {
2062 aurelien 315
							modifierMotCleDansArbreMediateur(nd);
155 aurelien 316
						}
317
					}
2062 aurelien 318
					//arbreMotsCles.disable();
155 aurelien 319
				}
2227 aurelien 320
 
321
				@Override
322
				public boolean doBeforeMoveNode(Tree tree, TreeNode node,
323
						TreeNode oldParent, TreeNode newParent, int index) {
324
					boolean ok = true;
325
					if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
326
						ok = false;
327
						Window.alert("Un mot clé de même nom existe déjà à cette position");
328
					}
329
					return ok;
330
				}
331
 
332
				@Override
333
				public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
334
						DragData dragData, String point, DragDrop source,
335
						TreeNode dropNode) {
2237 aurelien 336
					boolean ok = true;
337
					if(dragData instanceof TreeDragData) {
338
						ok = MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
339
					}
340
					return ok;
2227 aurelien 341
				}
155 aurelien 342
 
343
				// gestion du déplacement d'un noeud
1292 aurelien 344
				@Override
155 aurelien 345
				public void onMoveNode(Tree tree, TreeNode node,
346
						TreeNode oldParent, TreeNode newParent, int index) {
347
					// on notifie le médiateur et on lui passe l'arbre
348
					getOMediateur().deplacerMotCleDansArbre(node,
349
							getArbreMotsCles().getTree());
350
				}
318 aurelien 351
 
1292 aurelien 352
				@Override
318 aurelien 353
				public boolean doBeforeNodeDrop(TreePanel treePanel,
354
						TreeNode target, DragData dragData,
355
						String point, DragDrop source,
356
						TreeNode dropNode,
357
						DropNodeCallback dropNodeCallback) {
358
 
339 aurelien 359
					if(dragData instanceof TreeDragData) {
360
						return true;
361
					}
318 aurelien 362
 
339 aurelien 363
					String idMotCle = ((String[])target.getUserObject())[1];
364
 
365
					if(oMediateur.gererDDObsSurMotCle(target, dragData)) {
318 aurelien 366
 
339 aurelien 367
						cocherMotCle(idMotCle);
368
						return true;
369
					}
370
 
371
					return false;
318 aurelien 372
				}
155 aurelien 373
 
318 aurelien 374
 
1292 aurelien 375
				@Override
318 aurelien 376
				public void onNodeDrop(TreePanel treePanel,
377
						TreeNode target, DragData dragData,
378
						String point, DragDrop source, TreeNode dropNode) {
339 aurelien 379
 
318 aurelien 380
 
381
				}
382
 
155 aurelien 383
			});
384
 
385
			// gestion de la validation
318 aurelien 386
			ajouterMotCle.addListener(new ButtonListenerAdapter() {
155 aurelien 387
 
388
				// lors du clic
1292 aurelien 389
				@Override
155 aurelien 390
				public void onClick(Button button, EventObject e) {
318 aurelien 391
 
339 aurelien 392
					TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
393
					TreeNode noeudAjout;
394
					if(noeuds.length > 0) {
395
						noeudAjout = noeuds[noeuds.length - 1];
396
					} else {
397
						noeudAjout = arbreMotsCles.getRootNode();
398
					}
399
 
400
					ajouterNoeud(noeudAjout);
318 aurelien 401
 
155 aurelien 402
				}
403
			});
404
 
405
		}
318 aurelien 406
 
2062 aurelien 407
		private void ajouterMotCleDansArbreMediateur(TreeNode nd) {
408
			// on notifie le médiateur de l'ajout et on lui passe
409
			// l'arbre
410
			getOMediateur().ajouterMotCleDansArbre(nd,
411
					getArbreMotsCles().getTree(), this);
412
			// et considère l'ajout achevé
413
			ajoutNoeud = false;
414
		}
318 aurelien 415
 
2062 aurelien 416
		private void modifierMotCleDansArbreMediateur(TreeNode nd) {
417
			// on notifie le médiateur de la modification et on lui
418
			// passe l'arbre
419
			getOMediateur().modifierMotCleDansArbre(nd,
420
					getArbreMotsCles().getTree());
421
			// et on considère la modification achevée
422
			modifNoeud = false;
423
		}
424
 
318 aurelien 425
		/**
426
		 * Configure le drag 'n drop pour la liste
427
		 */
428
		private void configDragAndDrop()
429
		{
430
			// on fabrique la nouvelle configuration
431
			// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
432
			arbreMotsCles.setDdGroup("ObsMotsClesGroup");
433
			//arbreMotsCles.setEnableDD(true);
434
			arbreMotsCles.setEnableDrag(true);
435
			arbreMotsCles.setEnableDrop(true);
436
			DropTargetConfig dtc = new DropTargetConfig();
437
			dtc.setdDdGroup("ObsMotsClesGroup");
438
		}
439
 
155 aurelien 440
		/**
441
		 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
442
		 */
443
		public void obtenirArbreMotsCles() {
444
 
445
			getOMediateur().obtenirArbreMotsCles(this);
446
 
447
		}
448
 
449
		/**
450
		 * Supprime un noeud de l'arbre
451
		 *
452
		 * @param n
453
		 *            le noeud à supprimer
454
		 */
455
		public void supprimerNoeud(TreeNode n) {
456
			// si ça n'est pas la racine (qu'on ne peut pas supprimer)
457
			if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
339 aurelien 458
 
459
				if(Window.confirm("Etes vous sur de vouloir supprimer ce projet ?")) {
460
					// on détache le noeud et on le détruit
461
					n.getParentNode().removeChild(n);
462
					n.destroy();
463
					// puis on en notifie le médiateur en lui passant le noeud supprimé
464
					// et l'arbre
465
					getOMediateur()
2062 aurelien 466
							.supprimerMotCleDansArbre(n, arbreMotsCles.getTree(), this);
339 aurelien 467
				}
155 aurelien 468
			} else {
469
				// si l'utilisateur tente de supprimer la racine, on l'avertit de
470
				// son erreur
471
				Window.alert("Impossible de supprimer la racine de l'arbre");
472
			}
473
		}
474
 
475
		/**
476
		 * Ajoute un noeud dans l'arbre au parent donné
477
		 *
478
		 * @param parent
479
		 *            le futur parent du noeud à ajouter
480
		 */
481
		public void ajouterNoeud(TreeNode parent) {
2062 aurelien 482
			if(parent == null) {
483
				parent = arbreMotsCles.getRootNode();
484
			}
485
 
155 aurelien 486
			ajoutNoeud = true;
2042 aurelien 487
 
2062 aurelien 488
			TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false);
155 aurelien 489
			// on le concatène au parent et on étend ses enfants
490
			parent.appendChild(nd);
491
			parent.expand();
2062 aurelien 492
			cheminTemporaireAjout = nd.getId();
155 aurelien 493
			te.startEdit(nd);
494
		}
2042 aurelien 495
 
155 aurelien 496
		/**
318 aurelien 497
		 * Fonction de gestion sur le clic sur le noeud
155 aurelien 498
		 *
499
		 * @param node
500
		 */
318 aurelien 501
		public void gererClicNoeud(TreeNode node, boolean multi) {
502
 
339 aurelien 503
			if(!arbreCharge) {
504
				obtenirArbreMotsCles();
505
			} else {
506
				if(multi) {
507
				}
508
				((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi);
509
				oMediateur.obtenirNombreObservation();
510
			}
155 aurelien 511
		}
512
 
513
		/**
514
		 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
515
		 * clés à cocher
516
		 *
517
		 * @param motsClesIds
518
		 *            un tableau contenant les identifiants des mots clés à cocher
519
		 */
520
		public void cocherMotsCles(final String[] motsClesIds) {
521
			if (getArbreMotsCles() != null
522
					&& getArbreMotsCles().getRootNode() != null) {
523
				// à partir de la racine
524
				getArbreMotsCles().getRootNode().cascade(
525
						new NodeTraversalCallback() {
526
 
527
							// pour chaque noeud
1292 aurelien 528
							@Override
155 aurelien 529
							public boolean execute(Node node) {
530
 
531
								// on parcourt le tableau des mots clés
532
								for (int i = 0; i < motsClesIds.length; i++) {
533
									// si le mot clé fait partie des id à cocher on
534
									// le coche
535
									String usObject[] = (String[]) node
536
											.getUserObject();
537
									String nodeId = usObject[1];
538
									if (nodeId.equals(motsClesIds[i])) {
539
 
339 aurelien 540
										getArbreMotsCles().getNodeById(nodeId)
541
										.getUI().getTextEl().addClassName("x-tree-node-text-kw");
542
 
155 aurelien 543
											return true;
544
									}
545
								}
339 aurelien 546
 
547
								if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) {
548
									getArbreMotsCles().getNodeById(node.getId())
549
									.getUI().getTextEl().removeClassName("x-tree-node-text-kw");
550
								}
551
 
552
 
155 aurelien 553
								// et on passe au suivant
554
								return true;
555
							}
556
 
557
						});
558
			}
559
			else {
560
				motsClesEnAttente = motsClesIds ;
561
			}
562
		}
339 aurelien 563
 
564
		public void cocherMotCle(String motCleId) {
2277 aurelien 565
			if(getArbreMotsCles().getNodeById(motCleId) != null) {
566
				getArbreMotsCles().getNodeById(motCleId)
567
				.getUI().getTextEl().addClassName("x-tree-node-text-kw");
568
			}
569
 
339 aurelien 570
		}
571
 
572
		public void initialiser() {
573
 
574
			arbreCharge = false ;
575
			motsClesEnCours = "";
576
			arbreMotsCles.collapseAll();
577
			// on vide l'ancien arbre
578
			Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes();
579
			for (int i = 0; i < rootChild.length; i++) {
580
 
581
				rootChild[i].remove();
582
			}
583
 
584
			arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
585
 
1292 aurelien 586
				@Override
339 aurelien 587
				public void onExpand(Node node) {
588
					if(!arbreCharge)
589
					{
590
						obtenirArbreMotsCles() ;
591
						arbreCharge = true ;
592
					}
593
				}
594
 
595
			}) ;
596
		}
155 aurelien 597
 
598
		/**
599
		 * Méthode héritée de l'interface rafraichissable
600
		 *
601
		 * @param nouvelleDonnees
602
		 *            les nouvelles données pour l'objet
603
		 * @param repandreRafraichissement
604
		 *            booleen qui dit si on doit répandre l'évenement
605
		 */
1292 aurelien 606
		@Override
155 aurelien 607
		public void rafraichir(Object nouvelleDonnees,
608
				boolean repandreRafraichissement) {
2062 aurelien 609
 
610
			arbreMotsCles.enable();
155 aurelien 611
 
612
			if(nouvelleDonnees instanceof Tree) {
613
 
614
				Tree nouvelArbre = (Tree)nouvelleDonnees ;
615
 
616
				// on prend sa racine et on l'attache à l'arbre des mots clés
617
				Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
618
				for (int i = 0; i < rootChild.length; i++) {
619
 
620
					rootChild[i].remove();
621
				}
622
 
2062 aurelien 623
				MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), false);
155 aurelien 624
 
625
				// si l'arbre n'était pas encore considéré comme instancié
626
				if (!arbreCharge) {
627
					// on signale que oui
628
					arbreCharge = true;
629
				}
630
 
339 aurelien 631
 
155 aurelien 632
				// s'il y a des mots clés en attente (lors du premier rendering)
633
				if (motsCleInitialises == false && motsClesEnAttente != null) {
634
					// on les coche
339 aurelien 635
					cocherMotsCles(motsClesEnAttente) ;
155 aurelien 636
					motsCleInitialises = true;
637
				}
638
 
639
				if(motsClesEnAttente.length > 0) {
339 aurelien 640
					cocherMotsCles(motsClesEnAttente);
641
				}
155 aurelien 642
			}
643
 
644
			// Si on reçoit un tableau de String (cas ou l'on séléectionne une
318 aurelien 645
			// nouvelle obs)
339 aurelien 646
			if (nouvelleDonnees instanceof String) {
647
 
648
				String chaineMc = (String)nouvelleDonnees;
649
				String[] motsClesIds = chaineMc.split(";");
650
 
155 aurelien 651
				// et que l'arbre est instancié
652
				if (arbreCharge) {
653
					// le tableau de String contient les id des mots clés associés à
654
					// l'image
655
					// on coche les mots clés contenu dans le tableau
656
					cocherMotsCles(motsClesIds);
657
 
658
				}
659
				// si l'arbre n'est pas encore instancié on met les mots clés en
660
				// attente
661
				else {
1292 aurelien 662
					motsClesEnAttente = motsClesIds;
155 aurelien 663
				}
664
			}
339 aurelien 665
 
2042 aurelien 666
			// reception d'un nouvel identifiant de mot clé
667
			if(nouvelleDonnees instanceof Integer) {
2277 aurelien 668
				if(cheminTemporaireAjout != null) {
2042 aurelien 669
					String id = ((Integer)(nouvelleDonnees)).toString();
670
					TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
671
					String[] userObj = {noeudEnAjout.getText(), id};
672
					noeudEnAjout.setUserObject(userObj);
673
					cheminTemporaireAjout = null;
155 aurelien 674
				}
675
			}
676
		}
318 aurelien 677
 
678
		public void raz() {
679
 
339 aurelien 680
			arbreCharge = false ;
681
			arbreMotsCles.collapseAll();
682
			arbreMotsCles.clear() ;
683
 
684
			// on crée une racine pour l'arbre
685
			TreeNode root = new TreeNode("Projets");
686
			root.setId("racine_obs");
687
			String[] usObject = { "Projets", "racine_obs" };
688
			root.setUserObject(usObject);
689
			root.setExpandable(true);
690
 
691
			arbreMotsCles.setRootNode(root);
692
 
693
			arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
694
 
1292 aurelien 695
				@Override
339 aurelien 696
				public void onExpand(Node node) {
697
					if(!arbreCharge)
698
					{
699
						obtenirArbreMotsCles() ;
700
						arbreCharge = true ;
701
					}
702
				}
703
 
704
			}) ;
705
 
706
			motsClesEnCours  = "";
318 aurelien 707
		}
708
 
1292 aurelien 709
		@Override
318 aurelien 710
		public boolean renvoyerEtatFiltre() {
711
			// TODO Auto-generated method stub
712
			return false;
713
		}
714
 
1292 aurelien 715
		@Override
318 aurelien 716
		public String renvoyerNomFiltre() {
717
			// TODO Auto-generated method stub
718
			return null;
719
		}
720
 
1292 aurelien 721
		@Override
318 aurelien 722
		public String[] renvoyerValeursAFiltrer() {
335 aurelien 723
 
339 aurelien 724
			String val = "";
335 aurelien 725
 
339 aurelien 726
			TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
727
 
728
			for(int i = 0; i< noeuds.length ; i++) {
729
				if(noeuds[i].getDepth() > 0) {
2277 aurelien 730
					String usObject[] = (String[]) noeuds[i]
731
							.getUserObject();
732
					String nodeId = usObject[1];
733
					val += ";"+nodeId;
339 aurelien 734
				}
735
			}
736
 
737
			val = val.replaceFirst(";", "");
738
 
965 aurelien 739
			String[] valeursFiltres = {"id_mots_cles", val};
335 aurelien 740
 
741
			return valeursFiltres;
318 aurelien 742
		}
743
 
1292 aurelien 744
		@Override
318 aurelien 745
		public void valider() {
746
			// TODO Auto-generated method stub
747
 
748
		}
339 aurelien 749
 
750
 
751
		public void montrerContextMenuArbre(final TreeNode n, EventObject e,
752
				TreeEditor te) {
753
				Menu mn = new Menu();
754
				final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
755
						"Ajouter un projet");
756
				final com.gwtext.client.widgets.menu.Item suppN = new Item(
757
						"Supprimer projet");
758
 
759
				mn.addItem(ajoutN);
760
				mn.addItem(suppN);
761
 
762
				mn.addListener(new MenuListenerAdapter() {
763
 
1292 aurelien 764
					@Override
339 aurelien 765
					public void onItemClick(BaseItem item, EventObject e) {
766
						if (item.equals(suppN)) {
767
							supprimerNoeud(n);
768
						}
769
						if (item.equals(ajoutN)) {
770
							ajouterNoeud(n);
771
						}
772
					}
773
				});
774
 
775
				mn.showAt(e.getXY());
776
		}
683 aurelien 777
 
1292 aurelien 778
		@Override
683 aurelien 779
		public void viderFiltre() {
780
			arbreMotsCles.getSelectionModel().clearSelections();
781
			motsClesEnCours = "";
782
		}
155 aurelien 783
}