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
 
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
				}
2194 mathias 323
 
324
				if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) {
325
					te.startEdit(node);
326
					Window.alert("Un mot clé de même nom existe déjà à cette position");
327
					return;
328
				}
1018 aurelien 329
 
1118 aurelien 330
				if(node.equals(arbreMotsCles.getRootNode())) {
331
					return;
332
				}
333
 
1018 aurelien 334
				// on récupère les informations associées au noeud
335
				TreeNode nd = node;
336
				String[] usObject = new String[2];
337
				usObject[0] = text;
338
				usObject[1] = ((String[]) nd.getUserObject())[1];
339
				nd.setUserObject(usObject);
340
 
341
				// si c'est un nouveau noeud
342
				if (ajoutNoeud) {
343
					// on considère l'ajout achevé
344
					ajoutNoeud = false;
345
					// et on notifie le médiateur de l'ajout et on lui passe
346
					// l'arbre
347
					surAjoutMotCle(nd, getArbreMotsCles().getTree());
2148 aurelien 348
					arbreMotsCles.disable();
1018 aurelien 349
				}
350
				// si c'est noeud déjà existant
351
				else {
352
					// on considère la modification achevée
353
					modifNoeud = false;
354
 
355
					if(!text.equals(oldText)) {
356
						// et on notifie le médiateur de la modification et on lui
357
						// passe l'arbre
358
						surChangementTexte(nd, getArbreMotsCles().getTree());
2148 aurelien 359
						arbreMotsCles.disable();
1018 aurelien 360
					}
361
				}
362
			}
2194 mathias 363
 
364
			@Override
365
			public boolean doBeforeMoveNode(Tree tree, TreeNode node,
366
					TreeNode oldParent, TreeNode newParent, int index) {
367
				boolean ok = true;
368
				if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) {
369
					ok = false;
370
					Window.alert("Un mot clé de même nom existe déjà à cette position");
371
				}
372
				return ok;
373
			}
374
 
375
			@Override
376
			public boolean onNodeDragOver(TreePanel treePanel, TreeNode target,
377
					DragData dragData, String point, DragDrop source,
378
					TreeNode dropNode) {
379
				return MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText());
380
			}
1018 aurelien 381
 
382
			// gestion du déplacement d'un noeud
1292 aurelien 383
			@Override
1018 aurelien 384
			public void onMoveNode(Tree tree, TreeNode node,
385
					TreeNode oldParent, TreeNode newParent, int index) {
386
				// on notifie le médiateur et on lui passe l'arbre
387
				surDeplacementMotCle(node, getArbreMotsCles().getTree());
388
			}
389
 
390
		});
391
 
392
		// gestion de la validation
393
		valider.addListener(new ButtonListenerAdapter() {
394
 
395
			// lors du clic
1292 aurelien 396
			@Override
1018 aurelien 397
			public void onClick(Button button, EventObject e) {
398
 
399
				// on vide les mots clés en cours
400
				motsClesEnCours = "";
401
				// pour chaque noeud à partir de la racine
402
				getArbreMotsCles().getRootNode().cascade(
403
						new NodeTraversalCallback() {
404
 
405
							// on éxécute une fonction
1292 aurelien 406
							@Override
1018 aurelien 407
							public boolean execute(Node node) {
408
 
409
								// on récupère le mot clé associé au noeud et
410
								// ses infos
411
								TreeNode tn = getArbreMotsCles().getNodeById(
412
										node.getId());
413
 
414
								String[] usObject = (String[]) tn
415
										.getUserObject();
416
								/*getIMediateur().mettreAjourMotsClesId(
417
										usObject[0], usObject[1]);*/
418
 
419
								if (tn.getUI().isChecked()) {
420
									// et les concatène à la string des mots
421
									// clés en cours
422
									motsClesEnCours += usObject[1] + ",";
423
								}
424
 
425
								return true;
426
							}
427
 
428
						});
429
 
430
				// enfin on notifie le médiateur et on lui passe l'arbre et la
431
				// liste des mots clés ainsi obtenue
432
				surClicValider(motsClesEnCours, arbreMotsCles.getTree());
433
			}
434
		});
435
 
436
		annuler.addListener(new ButtonListenerAdapter() {
1292 aurelien 437
			@Override
1018 aurelien 438
			public void onClick(Button button, EventObject e) {
1118 aurelien 439
				hide();
1018 aurelien 440
			}
441
		});
1118 aurelien 442
 
443
		renommerTag.addListener(new ButtonListenerAdapter() {
1292 aurelien 444
			@Override
1118 aurelien 445
			public void onClick(Button button, EventObject e) {
446
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
447
				TreeNode noeudRenommage;
448
				if(noeuds.length > 0) {
449
					noeudRenommage = noeuds[noeuds.length - 1];
450
				} else {
451
					noeudRenommage = arbreMotsCles.getRootNode();
452
				}
453
				renommerNoeud(noeudRenommage);
454
			}
455
		});
456
 
457
		ajouterTag.addListener(new ButtonListenerAdapter() {
458
			@Override
459
			public void onClick(Button button, EventObject e) {
460
 
461
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
462
				TreeNode noeudAjout;
463
				if(noeuds.length > 0) {
464
					noeudAjout = noeuds[noeuds.length - 1];
465
				} else {
466
					noeudAjout = arbreMotsCles.getRootNode();
467
				}
468
 
469
				ajouterNoeud(noeudAjout);
470
			}
471
		});
472
 
473
		supprimerTag.addListener(new ButtonListenerAdapter() {
474
			@Override
475
			public void onClick(Button button, EventObject e) {
476
 
477
				TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes();
478
				for (int i = 0; i < noeuds.length; i++) {
479
					supprimerNoeud(noeuds[i]);
480
				}
481
			}
482
		});
1018 aurelien 483
	}
484
 
485
	/**
486
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
487
	 */
488
	public void obtenirArbreMotsCles() {
489
		demanderArbreMotsCles(this);
490
	}
491
 
492
	/**
493
	 * Supprime un noeud de l'arbre
494
	 *
495
	 * @param n
496
	 *            le noeud à supprimer
497
	 */
498
	public void supprimerNoeud(TreeNode n) {
499
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
500
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
1118 aurelien 501
			if(Window.confirm("Êtes vous sur de vouloir supprimer le mot clé "+n.getText()+" ?")) {
502
				// on détache le noeud et on le détruit
503
				n.getParentNode().removeChild(n);
504
				n.destroy();
505
				// puis on en notifie le médiateur en lui passant le noeud supprimé
506
				// et l'arbre
507
				surSuppressionMotCle(n, arbreMotsCles.getTree());
508
			}
1018 aurelien 509
		} else {
510
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
511
			// son erreur
512
			Window.alert("Impossible de supprimer la racine de l'arbre");
513
		}
514
	}
515
 
516
	/**
517
	 * Ajoute un noeud dans l'arbre au parent donné
518
	 *
519
	 * @param parent
520
	 *            le futur parent du noeud à ajouter
521
	 */
522
	public void ajouterNoeud(TreeNode parent) {
2062 aurelien 523
		ajoutNoeud = true;
524
		TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, true);
1018 aurelien 525
		// on le concatène au parent et on étend ses enfants
526
		parent.appendChild(nd);
527
		parent.expand();
2062 aurelien 528
		cheminTemporaireAjout = nd.getId();
1018 aurelien 529
		te.startEdit(nd);
530
	}
531
 
532
	/**
1118 aurelien 533
	 * Renomme le noeud passé en paramètre
534
	 */
535
	public void renommerNoeud(TreeNode n) {
536
		// TODO Auto-generated method stub
537
		te.startEdit(n);
538
	}
539
 
540
	/**
1018 aurelien 541
	 * Coche le noeud s'il est décoché, le décoche sinon
542
	 *
543
	 * @param node
544
	 */
545
	public void gererClicNoeud(TreeNode node) {
546
		if (node.getUI().isChecked()) {
547
			node.getUI().toggleCheck(false);
548
		} else {
549
			node.getUI().toggleCheck(true);
550
		}
551
	}
552
 
553
	/**
554
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
555
	 * clés à cocher
556
	 *
557
	 * @param motsClesIds
558
	 *            un tableau contenant les identifiants des mots clés à cocher
559
	 */
560
	public void cocherMotsCles(final String[] motsClesIds) {
561
		if (getArbreMotsCles() != null
562
				&& getArbreMotsCles().getRootNode() != null) {
563
			// à partir de la racine
564
			getArbreMotsCles().getRootNode().cascade(
2160 aurelien 565
				new NodeTraversalCallback() {
1018 aurelien 566
 
2160 aurelien 567
					// pour chaque noeud
568
					@Override
569
					public boolean execute(Node node) {
1018 aurelien 570
 
2160 aurelien 571
						String usObject[] = (String[]) node
572
								.getUserObject();
573
						String nodeId = usObject[1];
574
 
575
						TreeNode tn = getArbreMotsCles().getNodeById(node.getId());
576
						if(tn != null) {
577
							tn.getUI().toggleCheck(false);
1018 aurelien 578
							// on parcourt le tableau des mots clés
579
							for (int i = 0; i < motsClesIds.length; i++) {
580
								// si le mot clé fait partie des id à cocher on
581
								// le coche
582
 
583
								if (nodeId.equals(motsClesIds[i])) {
2160 aurelien 584
									tn.getUI().toggleCheck(true);
585
									tn.ensureVisible();
1018 aurelien 586
									return true;
587
								}
588
							}
589
							// et on passe au suivant
590
						}
2160 aurelien 591
 
592
						return true;
593
					}
1018 aurelien 594
 
2160 aurelien 595
				});
1018 aurelien 596
		}
597
	}
598
 
599
	/**
600
	 * Méthode héritée de l'interface rafraichissable
601
	 *
602
	 * @param nouvelleDonnees
603
	 *            les nouvelles données pour l'objet
604
	 * @param repandreRafraichissement
605
	 *            booleen qui dit si on doit répandre l'évenement
606
	 */
1292 aurelien 607
	@Override
1018 aurelien 608
	public void rafraichir(Object nouvelleDonnees,
609
			boolean repandreRafraichissement) {
610
 
611
		if(nouvelleDonnees instanceof Tree) {
612
 
613
			Tree nouvelArbre = (Tree)nouvelleDonnees ;
614
 
615
			// on prend sa racine et on l'attache à l'arbre des mots clés
616
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
617
			for (int i = 0; i < rootChild.length; i++) {
618
 
619
				rootChild[i].remove();
620
			}
621
 
622
			copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
623
 
624
			// si l'arbre n'était pas encore considéré comme instancié
625
			if (!arbreCharge) {
626
				// on signale que oui
627
				arbreCharge = true;
628
			}
629
		}
630
 
631
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
632
		// nouvelle image)
633
		if (nouvelleDonnees instanceof String[]) {
634
 
2062 aurelien 635
			// le tableau de String contient les id des mots clés associés à
636
			// l'image
637
			// on coche les mots clés contenu dans le tableau
638
			tableauMotsClesEnCours = (String[]) nouvelleDonnees;
639
			if(this.isVisible()) {
640
				cocherMotsCles(tableauMotsClesEnCours);
641
			} else {
642
				addListener(new WindowListenerAdapter() {
643
 
644
					@Override
645
					public void onShow(Component component) {
646
						cocherMotsCles(tableauMotsClesEnCours);
647
					}
648
				});
649
			}
1018 aurelien 650
		}
2062 aurelien 651
 
652
		// reception d'un nouvel identifiant de mot clé
653
		if(nouvelleDonnees instanceof Integer) {
654
			if(cheminTemporaireAjout != null) {
655
				String id = ((Integer)(nouvelleDonnees)).toString();
656
				TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
657
				String[] userObj = {noeudEnAjout.getText(), id};
658
				noeudEnAjout.setUserObject(userObj);
659
				cheminTemporaireAjout = null;
660
			}
661
		}
2166 aurelien 662
		surRetourWebService(arbreMotsCles.getTree());
2062 aurelien 663
		arbreMotsCles.enable();
1018 aurelien 664
	}
665
 
666
	/**
667
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
668
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
669
	 *
670
	 * @param ndPereOriginal
671
	 *            le père des noeuds de l'arbre original
672
	 * @param ndPereCopie
673
	 *            le père qui va recevoir les copies
674
	 */
675
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
676
		if (ndPereCopie != null && ndPereOriginal != null) {
677
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
678
 
679
			for (int i = 0; i < ndNodeFils.length; i++) {
680
 
681
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
682
				TreeNode child = new TreeNode(usObj[0]);
683
				child.setId(usObj[1]);
684
				child.setChecked(false);
685
				child.setUserObject(usObj);
686
				ndPereCopie.appendChild(child);
687
 
688
				if (!ndNodeFils[i].isLeaf()) {
689
					copierFilsNoeud(ndNodeFils[i], child);
690
				}
691
 
692
			}
693
		}
694
	}
695
 
696
 
697
	public void activerBoutonValider(boolean activer) {
698
		valider.setVisible(activer);
699
	}
700
}
701