Subversion Repositories eFlore/Applications.cel

Rev

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