Subversion Repositories eFlore/Applications.cel

Rev

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