Subversion Repositories eFlore/Applications.cel

Rev

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