Subversion Repositories eFlore/Applications.cel

Rev

Rev 2166 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1018 aurelien 1
package org.tela_botanica.client.vues.image;
2
 
2166 aurelien 3
import org.tela_botanica.client.cel2;
1018 aurelien 4
import org.tela_botanica.client.interfaces.Rafraichissable;
2062 aurelien 5
import org.tela_botanica.client.util.MotsClesUtilitaire;
1018 aurelien 6
 
1837 aurelien 7
import com.google.gwt.core.client.JavaScriptObject;
1018 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;
1837 aurelien 13
import com.gwtext.client.dd.DD;
14
import com.gwtext.client.dd.DragData;
15
import com.gwtext.client.dd.DragDrop;
16
import com.gwtext.client.widgets.BoxComponent;
1018 aurelien 17
import com.gwtext.client.widgets.Button;
18
import com.gwtext.client.widgets.Component;
1837 aurelien 19
import com.gwtext.client.widgets.Container;
1018 aurelien 20
import com.gwtext.client.widgets.Panel;
1118 aurelien 21
import com.gwtext.client.widgets.Toolbar;
22
import com.gwtext.client.widgets.ToolbarButton;
1018 aurelien 23
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
1837 aurelien 24
import com.gwtext.client.widgets.event.ContainerListener;
25
import com.gwtext.client.widgets.event.PanelListener;
26
import com.gwtext.client.widgets.event.WindowListener;
1018 aurelien 27
import com.gwtext.client.widgets.event.WindowListenerAdapter;
28
import com.gwtext.client.widgets.form.TextField;
1837 aurelien 29
import com.gwtext.client.widgets.layout.FitLayout;
1018 aurelien 30
import com.gwtext.client.widgets.layout.HorizontalLayout;
1837 aurelien 31
import com.gwtext.client.widgets.layout.RowLayout;
32
import com.gwtext.client.widgets.layout.RowLayoutData;
1018 aurelien 33
import com.gwtext.client.widgets.layout.VerticalLayout;
1837 aurelien 34
import com.gwtext.client.widgets.tree.DropNodeCallback;
1118 aurelien 35
import com.gwtext.client.widgets.tree.MultiSelectionModel;
1018 aurelien 36
import com.gwtext.client.widgets.tree.TreeEditor;
37
import com.gwtext.client.widgets.tree.TreeNode;
38
import com.gwtext.client.widgets.tree.TreePanel;
39
import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter;
1837 aurelien 40
import com.gwtext.client.widgets.tree.event.TreePanelListener;
1018 aurelien 41
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
42
 
43
/**
44
 * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
45
 * clés cochables et réorganisables à volonté
46
 *
47
 * @author aurelien
48
 *
49
 */
50
public abstract class FenetreGestionMotsCles extends com.gwtext.client.widgets.Window implements Rafraichissable {
51
 
52
	/**
53
	 * Le treepanel qui affiche l'arbre
54
	 */
55
	private TreePanel arbreMotsCles = null;
56
	/**
57
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
58
	 */
59
	private TreeEditor te = null;
60
	/**
61
	 * Le textfield associé à l'éditeur
62
	 */
63
	private TextField tfEdit = null;
64
	/**
65
	 * Bouton de validation
66
	 */
67
	private Button valider = null;
68
 
69
	/**
70
	 * Bouton d'annulation
71
	 */
72
	private Button annuler = null;
73
 
74
	/**
1118 aurelien 75
	 * Bouton d'ajout de tag
76
	 */
77
	private ToolbarButton ajouterTag = null;
78
 
79
	/**
80
	 * Bouton de suppression de tag
81
	 */
82
	private ToolbarButton supprimerTag = null;
83
 
84
	/**
85
	 * Bouton de renommage de tag
86
	 */
87
	private ToolbarButton renommerTag = null;
88
 
89
	/**
1018 aurelien 90
	 * Une string permettant connaitre les mots clés cochés en cours séparés par
91
	 * des virgules
92
	 */
93
	private String motsClesEnCours = "";
94
 
95
	private String[] tableauMotsClesEnCours = new String[0];
96
	/**
97
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
98
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
99
	 * du conteneur n'ai été effectué)
100
	 */
101
	private String[] motsClesEnAttente = new String[0];
102
	/**
103
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
104
	 * noeud
105
	 */
106
	private boolean ajoutNoeud = false;
107
	/**
108
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
109
	 * noeud
110
	 */
111
	private boolean modifNoeud = false;
112
	/**
113
	 * Booléen d'instanciation du conteneur
114
	 */
115
	private boolean arbreCharge = false;
116
	/**
117
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
118
	 */
119
	private boolean motsCleInitialises;
1837 aurelien 120
 
121
	/**
122
	 * panneau intermédiaire contenant l'arbre
123
	 */
124
	private Panel panelIntermediaire;
2062 aurelien 125
	private String cheminTemporaireAjout;
1018 aurelien 126
 
127
	/**
128
	 * Constructeur avec paramètre
129
	 *
130
	 * @param im
131
	 *            le médiateur à associer
132
	 */
133
	public FenetreGestionMotsCles() {
134
 
135
		// on crée le panel
136
		setTitle("Mots clés");
1837 aurelien 137
		this.setLayoutData(new RowLayout());
1018 aurelien 138
 
139
		// on crée le conteneur de l'arbre
140
		arbreMotsCles = new TreePanel();
141
		// on permet le drag and drop dans l'arbre
142
		arbreMotsCles.setEnableDD(true);
143
		arbreMotsCles.setId("x-view-tree-keyword-imgs");
144
 
1118 aurelien 145
		arbreMotsCles.setSelectionModel(new MultiSelectionModel());
146
 
1018 aurelien 147
		// on crée une racine pour l'arbre
148
		TreeNode root = new TreeNode("Tags");
149
		root.setId("racine");
150
		String[] usObject = { "Mots clés", "racine" };
151
		root.setExpandable(true);
152
		arbreMotsCles.setRootNode(root);
153
		arbreMotsCles.setRootVisible(true);
154
		arbreMotsCles.setBorder(false);
155
		arbreMotsCles.setWidth(500);
156
 
157
		root.setUserObject(usObject);
158
 
159
		arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() {
160
 
1292 aurelien 161
			@Override
1018 aurelien 162
			public void onClick(Node node, EventObject e) {
163
				if(!arbreCharge) {
164
					expand();
165
				}
166
			}
167
 
1292 aurelien 168
			@Override
1018 aurelien 169
			public void onExpand(Node node) {
170
				if(!arbreCharge) {
171
					obtenirArbreMotsCles();
172
					arbreCharge = true;
173
				}
174
			}
175
 
176
		});
177
 
178
		// on crée l'éditeur pour l'arbre
179
		tfEdit = new TextField();
180
		tfEdit.setAutoWidth(true);
181
		te = new TreeEditor(arbreMotsCles, tfEdit);
182
		valider = new Button("Appliquer");
183
		annuler = new Button("Annuler");
184
		arbreMotsCles.add(te);
185
 
1837 aurelien 186
		panelIntermediaire = new Panel();
187
		panelIntermediaire.setLayout(new FitLayout());
188
		panelIntermediaire.setAutoScroll(true);
189
		panelIntermediaire.setWidth("100%");
190
		arbreMotsCles.setWidth("100%");
191
		arbreMotsCles.setHeight("100%");
1018 aurelien 192
 
193
		Panel panelBoutons = new Panel();
1118 aurelien 194
		panelBoutons.setLayout(new HorizontalLayout(130));
1018 aurelien 195
		panelBoutons.setWidth("100%");
196
 
197
		// on met en forme le layout
198
		panelIntermediaire.add(arbreMotsCles);
199
		panelBoutons.add(annuler);
200
		panelBoutons.add(valider);
201
 
1837 aurelien 202
		this.add(panelIntermediaire, new RowLayoutData());
203
		this.add(panelBoutons, new RowLayoutData(30));
204
		arbreMotsCles.setHeight("100%");
205
		arbreMotsCles.setAutoScroll(true);
1018 aurelien 206
 
1118 aurelien 207
		Toolbar barreBouton = new Toolbar();
208
		ajouterTag = new ToolbarButton("Nouveau Tag");
209
		ajouterTag.setIcon("mot_cle_ajouter.png");
210
		renommerTag = new ToolbarButton("Renommer");
211
		renommerTag.setIcon("mot_cle_editer.png");
212
		renommerTag.disable();
213
		supprimerTag = new ToolbarButton("Supprimer");
214
		supprimerTag.setIcon("mot_cle_supprimer.png");
215
		supprimerTag.disable();
216
		barreBouton.addButton(ajouterTag);
217
		barreBouton.addSeparator();
218
		barreBouton.addButton(renommerTag);
219
		barreBouton.addSeparator();
220
		barreBouton.addButton(supprimerTag);
221
		this.setTopToolbar(barreBouton);
222
 
1018 aurelien 223
		setCloseAction(com.gwtext.client.widgets.Window.HIDE);
224
		// on ajoute les listeners
225
		ajouterListeners();
226
 
227
	}
228
 
229
 
230
	/**
231
	 * Acesseur pour l'arbre des mots clés
232
	 *
233
	 * @return le panel contenant l'arbre
234
	 */
235
	public TreePanel getArbreMotsCles() {
236
		return arbreMotsCles;
237
	}
238
 
239
	/**
240
	 * Accesseur pour l'éditeur
241
	 *
242
	 * @return l'éditeur associé à l'arbre
243
	 */
244
	public TreeEditor getTe() {
245
		return te;
246
	}
247
 
248
	/**
249
	 * Acesseur pour le TextField associé à l'éditeur
250
	 *
251
	 * @return le champ texte associé à l'éditeur
252
	 */
253
	public TextField getTfEdit() {
254
		return tfEdit;
255
	}
256
 
257
	protected abstract void surAffichageMenuContextuel(TreeNode node, EventObject e, TreeEditor te);
258
	protected abstract void surAjoutMotCle(TreeNode node, Tree arbre);
259
	protected abstract void surSuppressionMotCle(TreeNode node, Tree arbre);
260
	protected abstract void surDeplacementMotCle(TreeNode node, Tree arbre);
261
	protected abstract void surChangementTexte(TreeNode node, Tree arbre);
262
	protected abstract void surClicValider(String chaineMotsCles, Tree arbre);
263
	protected abstract void demanderArbreMotsCles(Rafraichissable r);
2166 aurelien 264
	protected abstract void surRetourWebService(Tree arbre);
1018 aurelien 265
 
266
	/**
267
	 * Ajoute les listeners nécessaires pour la gestion des évènements
268
	 */
269
	private void ajouterListeners() {
1837 aurelien 270
 
271
		this.addListener(new WindowListenerAdapter() {
272
			@Override
273
			public void onResize(com.gwtext.client.widgets.Window source, int width,
274
					int height) {
275
					panelIntermediaire.setHeight(getHeight() - 80);
276
			}
277
		});
1018 aurelien 278
 
279
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
1837 aurelien 280
			@Override
281
			public void onAfterLayout(Container self) {
282
				panelIntermediaire.setHeight(getHeight() - 80);
283
			}
1018 aurelien 284
 
1292 aurelien 285
			@Override
1018 aurelien 286
			public void onExpandNode(TreeNode node) {
287
				cocherMotsCles(tableauMotsClesEnCours);
288
			}
289
 
290
			// gestion du clic sur un noeud
1292 aurelien 291
			@Override
1018 aurelien 292
			public void onClick(TreeNode node, EventObject e) {
293
 
294
				e.stopEvent();
295
				gererClicNoeud(node);
1118 aurelien 296
				if(!node.equals(arbreMotsCles.getRootNode())) {
297
					supprimerTag.enable();
298
					renommerTag.enable();
299
				}
1018 aurelien 300
			}
301
 
302
			// gestion du clic droit sur un noeud
1292 aurelien 303
			@Override
1018 aurelien 304
			public void onContextMenu(TreeNode node, EventObject e) {
305
 
306
				e.stopEvent();
307
				surAffichageMenuContextuel(node, e, getTe());
1118 aurelien 308
				if(!node.equals(arbreMotsCles.getRootNode())) {
309
					supprimerTag.enable();
310
					renommerTag.enable();
1018 aurelien 311
				}
312
			}
313
 
314
			// gestion de la modification du texte d'un noeud
1292 aurelien 315
			@Override
1018 aurelien 316
			public void onTextChange(TreeNode node, String text, String oldText) {
2062 aurelien 317
 
318
				if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) {
319
					te.startEdit(node);
320
					Window.alert("Un mot clé ne peut pas être vide ou contenir les caractères suivants : "+MotsClesUtilitaire.getChaineCaracteresInterdits());
321
					return;
322
				}
1018 aurelien 323
 
1118 aurelien 324
				if(node.equals(arbreMotsCles.getRootNode())) {
325
					return;
326
				}
327
 
1018 aurelien 328
				// on récupère les informations associées au noeud
329
				TreeNode nd = node;
330
				String[] usObject = new String[2];
331
				usObject[0] = text;
332
				usObject[1] = ((String[]) nd.getUserObject())[1];
333
				nd.setUserObject(usObject);
334
 
335
				// si c'est un nouveau noeud
336
				if (ajoutNoeud) {
337
					// on considère l'ajout achevé
338
					ajoutNoeud = false;
339
					// et on notifie le médiateur de l'ajout et on lui passe
340
					// l'arbre
341
					surAjoutMotCle(nd, getArbreMotsCles().getTree());
2148 aurelien 342
					arbreMotsCles.disable();
1018 aurelien 343
				}
344
				// si c'est noeud déjà existant
345
				else {
346
					// on considère la modification achevée
347
					modifNoeud = false;
348
 
349
					if(!text.equals(oldText)) {
350
						// et on notifie le médiateur de la modification et on lui
351
						// passe l'arbre
352
						surChangementTexte(nd, getArbreMotsCles().getTree());
2148 aurelien 353
						arbreMotsCles.disable();
1018 aurelien 354
					}
355
				}
356
			}
357
 
358
			// gestion du déplacement d'un noeud
1292 aurelien 359
			@Override
1018 aurelien 360
			public void onMoveNode(Tree tree, TreeNode node,
361
					TreeNode oldParent, TreeNode newParent, int index) {
362
				// on notifie le médiateur et on lui passe l'arbre
363
				surDeplacementMotCle(node, getArbreMotsCles().getTree());
364
			}
365
 
366
		});
367
 
368
		// gestion de la validation
369
		valider.addListener(new ButtonListenerAdapter() {
370
 
371
			// lors du clic
1292 aurelien 372
			@Override
1018 aurelien 373
			public void onClick(Button button, EventObject e) {
374
 
375
				// on vide les mots clés en cours
376
				motsClesEnCours = "";
377
				// pour chaque noeud à partir de la racine
378
				getArbreMotsCles().getRootNode().cascade(
379
						new NodeTraversalCallback() {
380
 
381
							// on éxécute une fonction
1292 aurelien 382
							@Override
1018 aurelien 383
							public boolean execute(Node node) {
384
 
385
								// on récupère le mot clé associé au noeud et
386
								// ses infos
387
								TreeNode tn = getArbreMotsCles().getNodeById(
388
										node.getId());
389
 
390
								String[] usObject = (String[]) tn
391
										.getUserObject();
392
								/*getIMediateur().mettreAjourMotsClesId(
393
										usObject[0], usObject[1]);*/
394
 
395
								if (tn.getUI().isChecked()) {
396
									// et les concatène à la string des mots
397
									// clés en cours
398
									motsClesEnCours += usObject[1] + ",";
399
								}
400
 
401
								return true;
402
							}
403
 
404
						});
405
 
406
				// enfin on notifie le médiateur et on lui passe l'arbre et la
407
				// liste des mots clés ainsi obtenue
408
				surClicValider(motsClesEnCours, arbreMotsCles.getTree());
409
			}
410
		});
411
 
412
		annuler.addListener(new ButtonListenerAdapter() {
1292 aurelien 413
			@Override
1018 aurelien 414
			public void onClick(Button button, EventObject e) {
1118 aurelien 415
				hide();
1018 aurelien 416
			}
417
		});
1118 aurelien 418
 
419
		renommerTag.addListener(new ButtonListenerAdapter() {
1292 aurelien 420
			@Override
1118 aurelien 421
			public void onClick(Button button, EventObject e) {
422
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
423
				TreeNode noeudRenommage;
424
				if(noeuds.length > 0) {
425
					noeudRenommage = noeuds[noeuds.length - 1];
426
				} else {
427
					noeudRenommage = arbreMotsCles.getRootNode();
428
				}
429
				renommerNoeud(noeudRenommage);
430
			}
431
		});
432
 
433
		ajouterTag.addListener(new ButtonListenerAdapter() {
434
			@Override
435
			public void onClick(Button button, EventObject e) {
436
 
437
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
438
				TreeNode noeudAjout;
439
				if(noeuds.length > 0) {
440
					noeudAjout = noeuds[noeuds.length - 1];
441
				} else {
442
					noeudAjout = arbreMotsCles.getRootNode();
443
				}
444
 
445
				ajouterNoeud(noeudAjout);
446
			}
447
		});
448
 
449
		supprimerTag.addListener(new ButtonListenerAdapter() {
450
			@Override
451
			public void onClick(Button button, EventObject e) {
452
 
453
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
454
				for (int i = 0; i < noeuds.length; i++) {
455
					supprimerNoeud(noeuds[i]);
456
				}
457
			}
458
		});
1018 aurelien 459
	}
460
 
461
	/**
462
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
463
	 */
464
	public void obtenirArbreMotsCles() {
465
		demanderArbreMotsCles(this);
466
	}
467
 
468
	/**
469
	 * Supprime un noeud de l'arbre
470
	 *
471
	 * @param n
472
	 *            le noeud à supprimer
473
	 */
474
	public void supprimerNoeud(TreeNode n) {
475
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
476
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
1118 aurelien 477
			if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
478
				// on détache le noeud et on le détruit
479
				n.getParentNode().removeChild(n);
480
				n.destroy();
481
				// puis on en notifie le médiateur en lui passant le noeud supprimé
482
				// et l'arbre
483
				surSuppressionMotCle(n, arbreMotsCles.getTree());
484
			}
1018 aurelien 485
		} else {
486
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
487
			// son erreur
488
			Window.alert("Impossible de supprimer la racine de l'arbre");
489
		}
490
	}
491
 
492
	/**
493
	 * Ajoute un noeud dans l'arbre au parent donné
494
	 *
495
	 * @param parent
496
	 *            le futur parent du noeud à ajouter
497
	 */
498
	public void ajouterNoeud(TreeNode parent) {
2062 aurelien 499
		ajoutNoeud = true;
500
		TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
1018 aurelien 501
		// on le concatène au parent et on étend ses enfants
502
		parent.appendChild(nd);
503
		parent.expand();
2062 aurelien 504
		cheminTemporaireAjout = nd.getId();
1018 aurelien 505
		te.startEdit(nd);
506
	}
507
 
508
	/**
1118 aurelien 509
	 * Renomme le noeud passé en paramètre
510
	 */
511
	public void renommerNoeud(TreeNode n) {
512
		// TODO Auto-generated method stub
513
		te.startEdit(n);
514
	}
515
 
516
	/**
1018 aurelien 517
	 * Coche le noeud s'il est décoché, le décoche sinon
518
	 *
519
	 * @param node
520
	 */
521
	public void gererClicNoeud(TreeNode node) {
522
		if (node.getUI().isChecked()) {
523
			node.getUI().toggleCheck(false);
524
		} else {
525
			node.getUI().toggleCheck(true);
526
		}
527
	}
528
 
529
	/**
530
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
531
	 * clés à cocher
532
	 *
533
	 * @param motsClesIds
534
	 *            un tableau contenant les identifiants des mots clés à cocher
535
	 */
536
	public void cocherMotsCles(final String[] motsClesIds) {
537
		if (getArbreMotsCles() != null
538
				&& getArbreMotsCles().getRootNode() != null) {
539
			// à partir de la racine
540
			getArbreMotsCles().getRootNode().cascade(
2160 aurelien 541
				new NodeTraversalCallback() {
1018 aurelien 542
 
2160 aurelien 543
					// pour chaque noeud
544
					@Override
545
					public boolean execute(Node node) {
1018 aurelien 546
 
2160 aurelien 547
						String usObject[] = (String[]) node
548
								.getUserObject();
549
						String nodeId = usObject[1];
550
 
551
						TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
552
						if(tn != null) {
553
							tn.getUI().toggleCheck(false);
1018 aurelien 554
							// on parcourt le tableau des mots clés
555
							for (int i = 0; i < motsClesIds.length; i++) {
556
								// si le mot clé fait partie des id à cocher on
557
								// le coche
558
 
559
								if (nodeId.equals(motsClesIds[i])) {
2160 aurelien 560
									tn.getUI().toggleCheck(true);
561
									tn.ensureVisible();
1018 aurelien 562
									return true;
563
								}
564
							}
565
							// et on passe au suivant
566
						}
2160 aurelien 567
 
568
						return true;
569
					}
1018 aurelien 570
 
2160 aurelien 571
				});
1018 aurelien 572
		}
573
	}
574
 
575
	/**
576
	 * Méthode héritée de l'interface rafraichissable
577
	 *
578
	 * @param nouvelleDonnees
579
	 *            les nouvelles données pour l'objet
580
	 * @param repandreRafraichissement
581
	 *            booleen qui dit si on doit répandre l'évenement
582
	 */
1292 aurelien 583
	@Override
1018 aurelien 584
	public void rafraichir(Object nouvelleDonnees,
585
			boolean repandreRafraichissement) {
586
 
587
		if(nouvelleDonnees instanceof Tree) {
588
 
589
			Tree nouvelArbre = (Tree)nouvelleDonnees ;
590
 
591
			// on prend sa racine et on l'attache à l'arbre des mots clés
592
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
593
			for (int i = 0; i < rootChild.length; i++) {
594
 
595
				rootChild[i].remove();
596
			}
597
 
598
			copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
599
 
600
			// si l'arbre n'était pas encore considéré comme instancié
601
			if (!arbreCharge) {
602
				// on signale que oui
603
				arbreCharge = true;
604
			}
605
		}
606
 
607
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
608
		// nouvelle image)
609
		if (nouvelleDonnees instanceof String[]) {
610
 
2062 aurelien 611
			// le tableau de String contient les id des mots clés associés à
612
			// l'image
613
			// on coche les mots clés contenu dans le tableau
614
			tableauMotsClesEnCours = (String[]) nouvelleDonnees;
615
			if(this.isVisible()) {
616
				cocherMotsCles(tableauMotsClesEnCours);
617
			} else {
618
				addListener(new WindowListenerAdapter() {
619
 
620
					@Override
621
					public void onShow(Component component) {
622
						cocherMotsCles(tableauMotsClesEnCours);
623
					}
624
				});
625
			}
1018 aurelien 626
		}
2062 aurelien 627
 
628
		// reception d'un nouvel identifiant de mot clé
629
		if(nouvelleDonnees instanceof Integer) {
630
			if(cheminTemporaireAjout != null) {
631
				String id = ((Integer)(nouvelleDonnees)).toString();
632
				TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
633
				String[] userObj = {noeudEnAjout.getText(), id};
634
				noeudEnAjout.setUserObject(userObj);
635
				cheminTemporaireAjout = null;
636
			}
637
		}
2166 aurelien 638
		surRetourWebService(arbreMotsCles.getTree());
2062 aurelien 639
		arbreMotsCles.enable();
1018 aurelien 640
	}
641
 
642
	/**
643
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
644
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
645
	 *
646
	 * @param ndPereOriginal
647
	 *            le père des noeuds de l'arbre original
648
	 * @param ndPereCopie
649
	 *            le père qui va recevoir les copies
650
	 */
651
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
652
		if (ndPereCopie != null && ndPereOriginal != null) {
653
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
654
 
655
			for (int i = 0; i < ndNodeFils.length; i++) {
656
 
657
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
658
				TreeNode child = new TreeNode(usObj[0]);
659
				child.setId(usObj[1]);
660
				child.setChecked(false);
661
				child.setUserObject(usObj);
662
				ndPereCopie.appendChild(child);
663
 
664
				if (!ndNodeFils[i].isLeaf()) {
665
					copierFilsNoeud(ndNodeFils[i], child);
666
				}
667
 
668
			}
669
		}
670
	}
671
 
672
 
673
	public void activerBoutonValider(boolean activer) {
674
		valider.setVisible(activer);
675
	}
676
}
677