Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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