Subversion Repositories eFlore/Applications.cel

Rev

Rev 2 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2 Rev 5
Line 1... Line 1...
1
package org.tela_botanica.client.vues;
1
package org.tela_botanica.client.vues;
Line 2... Line -...
2
 
-
 
3
 
-
 
4
 
2
 
5
import org.tela_botanica.client.image.ImageMediateur;
3
import org.tela_botanica.client.image.ImageMediateur;
Line 6... Line 4...
6
import org.tela_botanica.client.interfaces.Rafraichissable;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
7
 
5
 
Line 19... Line 17...
19
import com.gwtext.client.widgets.tree.TreeNode;
17
import com.gwtext.client.widgets.tree.TreeNode;
20
import com.gwtext.client.widgets.tree.TreePanel;
18
import com.gwtext.client.widgets.tree.TreePanel;
21
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
19
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
Line 22... Line 20...
22
 
20
 
23
/**
21
/**
24
 * Arbre des mots clés, qui est une vue rafraichissable,
22
 * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
-
 
23
 * clés cochables et réorganisables à volonté
25
 * qui contient des mots clés cochables et réorganisables à volonté
24
 * 
26
 * @author aurelien
25
 * @author aurelien
27
 *
26
 * 
28
 */
27
 */
Line 29... Line 28...
29
public class ArbreMotsClesVue extends Panel implements Rafraichissable {
28
public class ArbreMotsClesVue extends Panel implements Rafraichissable {
30
 
29
 
31
	/**
30
	/**
32
	 * Le médiateur associé à la vue
31
	 * Le médiateur associé à la vue
33
	 */
32
	 */
34
	private ImageMediateur iMediateur = null ;
33
	private ImageMediateur iMediateur = null;
35
	
34
 
36
	/**
35
	/**
37
	 * Le treepanel qui affiche l'arbre
36
	 * Le treepanel qui affiche l'arbre
38
	 */
37
	 */
39
	private TreePanel arbreMotsCles = null ;
38
	private TreePanel arbreMotsCles = null;
40
	/**
39
	/**
41
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
40
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
42
	 */
41
	 */
43
	private TreeEditor te = null ;
42
	private TreeEditor te = null;
44
	/**
43
	/**
45
	 * Le textfield associé à l'éditeur
44
	 * Le textfield associé à l'éditeur
46
	 */
45
	 */
47
	private TextField tfEdit = null ;
46
	private TextField tfEdit = null;
48
	/**
47
	/**
49
	 * Bouton de validation
48
	 * Bouton de validation
50
	 */
49
	 */
51
	private Button valider = null ;
50
	private Button valider = null;
-
 
51
	/**
52
	/**
52
	 * Une string permettant connaitre les mots clés cochés en cours séparés par
53
	 * Une string permettant connaitre les mots clés cochés en cours séparés par des virgules
53
	 * des virgules
54
	 */
54
	 */
55
	private String motsClesEnCours = "" ;
55
	private String motsClesEnCours = "";
56
	/**
56
	/**
-
 
57
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
57
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre 
58
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
58
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu du conteneur n'ai été effectué)
59
	 * du conteneur n'ai été effectué)
59
	 */
60
	 */
60
	private String[] motsClesEnAttente ; 
61
	private String[] motsClesEnAttente;
-
 
62
	/**
61
	/**
63
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
62
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un noeud
64
	 * noeud
63
	 */
65
	 */
64
	private boolean ajoutNoeud = false ;
66
	private boolean ajoutNoeud = false;
-
 
67
	/**
65
	/**
68
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
66
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un noeud
69
	 * noeud
67
	 */
70
	 */
68
	private boolean modifNoeud = false ;
71
	private boolean modifNoeud = false;
69
	/**
72
	/**
70
	 * Booléen d'instanciation du conteneur
73
	 * Booléen d'instanciation du conteneur
71
	 */
74
	 */
72
	private boolean estInstancie = false ;
75
	private boolean estInstancie = false;
73
	/**
76
	/**
74
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
77
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
75
	 */
78
	 */
76
	private boolean motsCleInitialises ;
79
	private boolean motsCleInitialises;
77
	
80
 
78
	/**
81
	/**
79
	 * Constructeur sans paramètre (privé car interdit d'utilisation)
82
	 * Constructeur sans paramètre (privé car interdit d'utilisation)
80
	 */
83
	 */
81
	@SuppressWarnings("unused")
-
 
82
	private ArbreMotsClesVue()
84
	@SuppressWarnings("unused")
83
	{
85
	private ArbreMotsClesVue() {
84
		super() ;
86
		super();
85
	}
87
	}
86
	
88
 
-
 
89
	/**
-
 
90
	 * Constructeur avec paramètre
87
	/**
91
	 * 
88
	 * Constructeur avec paramètre
92
	 * @param im
89
	 * @param im le médiateur à associer
93
	 *            le médiateur à associer
90
	 */
-
 
91
	public ArbreMotsClesVue(ImageMediateur im)
94
	 */
92
	{
95
	public ArbreMotsClesVue(ImageMediateur im) {
93
		// on crée le panel
96
		// on crée le panel
94
		super("Mots clés") ;
97
		super("Mots clés");
95
		this.setLayout(new VerticalLayout());
98
		this.setLayout(new VerticalLayout());
96
		iMediateur = im ;
99
		iMediateur = im;
97
		
100
 
98
		// on crée le conteneur de l'arbre
101
		// on crée le conteneur de l'arbre
99
		arbreMotsCles = new TreePanel() ;
102
		arbreMotsCles = new TreePanel();
100
		// on permet le drag and drop dans l'arbre
103
		// on permet le drag and drop dans l'arbre
101
		arbreMotsCles.setEnableDD(true) ;
104
		arbreMotsCles.setEnableDD(true);
102
		arbreMotsCles.setId("x-view-tree-keyword") ;
105
		arbreMotsCles.setId("x-view-tree-keyword");
103
		
106
 
104
		// on crée une racine pour l'arbre
107
		// on crée une racine pour l'arbre
105
		TreeNode root = new TreeNode("Tags") ;
108
		TreeNode root = new TreeNode("Tags");
106
		root.setId("racine") ;
109
		root.setId("racine");
107
		String[] usObject = {"Mots clés" , "racine" } ;
110
		String[] usObject = { "Mots clés", "racine" };
108
		root.setUserObject(usObject) ;
111
		root.setUserObject(usObject);
109
		arbreMotsCles.setRootNode(root) ;
112
		arbreMotsCles.setRootNode(root);
110
		arbreMotsCles.setRootVisible(false) ;
113
		arbreMotsCles.setRootVisible(false);
111
		arbreMotsCles.setBorder(false) ;
114
		arbreMotsCles.setBorder(false);
112
		arbreMotsCles.setWidth(500) ;
115
		arbreMotsCles.setWidth(500);
113
		
116
 
114
		// on crée l'éditeur pour l'arbre
117
		// on crée l'éditeur pour l'arbre
115
		tfEdit = new TextField() ;
118
		tfEdit = new TextField();
116
		tfEdit.setAutoWidth(true) ;
119
		tfEdit.setAutoWidth(true);
117
		te = new TreeEditor(arbreMotsCles,tfEdit) ;
120
		te = new TreeEditor(arbreMotsCles, tfEdit);
118
		valider = new Button("Appliquer") ;
121
		valider = new Button("Appliquer");
119
		arbreMotsCles.add(te) ;
122
		arbreMotsCles.add(te);
120
		
123
 
121
		// on met en forme le layout
124
		// on met en forme le layout
122
		this.add(arbreMotsCles) ;
125
		this.add(arbreMotsCles);
123
		this.add(valider) ;
126
		this.add(valider);
124
		
127
 
125
		this.setBorder(false) ;
128
		this.setBorder(false);
126
		this.setCollapsible(true) ;
129
		this.setCollapsible(true);
127
		this.setTitleCollapse(true) ;
130
		this.setTitleCollapse(true);
128
		
131
 
129
		// on ajoute les listeners
132
		// on ajoute les listeners
130
		ajouterListeners() ;
133
		ajouterListeners();
131
		
134
 
132
	}
135
	}
133
	
136
 
-
 
137
	/**
134
	/**
138
	 * Acesseur pour le médiateur
135
	 * Acesseur pour le médiateur
139
	 * 
136
	 * @return le médiateur associé à la vue
140
	 * @return le médiateur associé à la vue
137
	 */
141
	 */
138
	private ImageMediateur GetIMediateur() {
142
	private ImageMediateur GetIMediateur() {
139
		
143
 
140
		return iMediateur ;
144
		return iMediateur;
141
		
145
 
142
	}
146
	}
143
	
147
 
-
 
148
	/**
144
	/**
149
	 * Acesseur pour l'arbre des mots clés
145
	 * Acesseur pour l'arbre des mots clés
150
	 * 
146
	 * @return le panel contenant l'arbre
151
	 * @return le panel contenant l'arbre
147
	 */
152
	 */
148
	public TreePanel getArbreMotsCles() {
153
	public TreePanel getArbreMotsCles() {
Line 149... Line 154...
149
		return arbreMotsCles;
154
		return arbreMotsCles;
150
	}
155
	}
-
 
156
 
151
 
157
	/**
152
	/**
158
	 * Accesseur pour l'éditeur
153
	 * Accesseur pour l'éditeur
159
	 * 
154
	 * @return l'éditeur associé à l'arbre
160
	 * @return l'éditeur associé à l'arbre
155
	 */
161
	 */
Line 156... Line 162...
156
	public TreeEditor getTe() {
162
	public TreeEditor getTe() {
157
		return te;
163
		return te;
-
 
164
	}
158
	}
165
 
159
 
166
	/**
160
	/**
167
	 * Acesseur pour le TextField associé à l'éditeur
161
	 * Acesseur pour le TextField associé à l'éditeur
168
	 * 
162
	 * @return le champ texte associé à l'éditeur
169
	 * @return le champ texte associé à l'éditeur
163
	 */
170
	 */
164
	public TextField getTfEdit() {
171
	public TextField getTfEdit() {
165
		return tfEdit;
172
		return tfEdit;
166
	}
173
	}
167
	
174
 
168
	/**
-
 
169
	 * Ajoute les listeners nécessaires pour la gestion des évènements
175
	/**
170
	 */
176
	 * Ajoute les listeners nécessaires pour la gestion des évènements
171
	private void ajouterListeners()
177
	 */
172
	{
178
	private void ajouterListeners() {
173
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
179
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
174
			
180
 
175
			// gestion du clic sur un noeud
181
			// gestion du clic sur un noeud
176
			public void onClick(TreeNode node, EventObject e) {
182
			public void onClick(TreeNode node, EventObject e) {
Line 177... Line 183...
177
				
183
 
178
				e.stopEvent() ;
184
				e.stopEvent();
179
				gererClicNoeud(node);
185
				gererClicNoeud(node);
180
			}
186
			}
181
 
187
 
182
			// gestion du clic droit sur un noeud
188
			// gestion du clic droit sur un noeud
183
			public void onContextMenu(TreeNode node, EventObject e) {
189
			public void onContextMenu(TreeNode node, EventObject e) {
184
				
190
 
185
					e.stopEvent() ;
191
				e.stopEvent();
186
					GetIMediateur().montrerContextMenuArbre(node, e , getTe()) ;
192
				GetIMediateur().montrerContextMenuArbre(node, e, getTe());
187
				
193
 
188
			}
194
			}
189
		
195
 
190
			// gestion du double clic sur un noeud
-
 
191
			public void onDblClick(TreeNode node, EventObject e) {
196
			// gestion du double clic sur un noeud
192
				
197
			public void onDblClick(TreeNode node, EventObject e) {
193
				modifNoeud = true ;
198
 
194
				if(! node.getId().equals("racine"))
199
				modifNoeud = true;
195
				{
200
				if (!node.getId().equals("racine")) {
196
					te.startEdit(node);
201
					te.startEdit(node);
Line 197... Line 202...
197
				}
202
				}
198
			}
203
			}
199
			
204
 
200
			// gestion de la modification du texte d'un noeud 
205
			// gestion de la modification du texte d'un noeud
201
			public void onTextChange(TreeNode node, String text, String oldText) {
206
			public void onTextChange(TreeNode node, String text, String oldText) {
202
 
207
 
203
				// on récupère les informations associées au noeud
208
				// on récupère les informations associées au noeud
204
				TreeNode nd = node ;
209
				TreeNode nd = node;
205
				String[] usObject = new String[2] ;
210
				String[] usObject = new String[2];
206
				usObject[0] = text ;
-
 
207
				usObject[1] = ((String[])nd.getUserObject())[1] ;
211
				usObject[0] = text;
-
 
212
				usObject[1] = ((String[]) nd.getUserObject())[1];
208
				nd.setUserObject(usObject) ;
213
				nd.setUserObject(usObject);
-
 
214
 
209
				
215
				// si c'est un nouveau noeud
210
				// si c'est un nouveau noeud
216
				if (ajoutNoeud) {
211
				if(ajoutNoeud)
217
					// on notifie le médiateur de l'ajout et on lui passe
212
				{
218
					// l'arbre
213
					// on notifie le médiateur de l'ajout et on lui passe l'arbre
219
					GetIMediateur().ajouterMotCleDansArbre(nd,
214
					GetIMediateur().ajouterMotCleDansArbre(nd,getArbreMotsCles().getTree()) ;
-
 
215
					// et considière l'ajout achevé
220
							getArbreMotsCles().getTree());
216
					ajoutNoeud = false ;
-
 
217
				}
221
					// et considière l'ajout achevé
-
 
222
					ajoutNoeud = false;
218
				// si c'est noeud déjà existant
223
				}
-
 
224
				// si c'est noeud déjà existant
219
				else
225
				else {
220
				{
226
					if (modifNoeud) {
221
					if(modifNoeud)
227
						// on notifie le médiateur de la modification et on lui
222
					{
228
						// passe l'arbre
223
						// on notifie le médiateur de la modification et on lui passe l'arbre
229
						GetIMediateur().modifierMotCleDansArbre(nd,
224
						GetIMediateur().modifierMotCleDansArbre(nd,getArbreMotsCles().getTree()) ;
230
								getArbreMotsCles().getTree());
225
						// et on considère la modification achevée
231
						// et on considère la modification achevée
226
						modifNoeud = false ;
232
						modifNoeud = false;
227
					}
233
					}
228
				}
-
 
-
 
234
				}
229
				
235
 
230
			}
236
			}
-
 
237
 
231
			
238
			// gestion du déplacement d'un noeud
232
			// gestion du déplacement d'un noeud
239
			public void onMoveNode(Tree tree, TreeNode node,
233
			public void onMoveNode(Tree tree, TreeNode node, TreeNode oldParent, TreeNode newParent,int index)
240
					TreeNode oldParent, TreeNode newParent, int index) {
234
			{
241
				// on notifie le médiateur et on lui passe l'arbre
235
				// on notifie le médiateur et on lui passe l'arbre
242
				GetIMediateur().deplacerMotCleDansArbre(node,
236
				GetIMediateur().deplacerMotCleDansArbre(node, getArbreMotsCles().getTree()) ;
243
						getArbreMotsCles().getTree());
237
			} 
244
			}
238
			
245
 
239
		}) ;
246
		});
240
		
247
 
241
		// gestion de la validation
248
		// gestion de la validation
242
		valider.addListener(new ButtonListenerAdapter() {
249
		valider.addListener(new ButtonListenerAdapter() {
243
			
250
 
244
			// lors du clic
251
			// lors du clic
-
 
252
			public void onClick(Button button, EventObject e) {
245
			public void onClick(Button button, EventObject e) {
253
 
246
				
254
				// on vide les mots clés en cours
247
				// on vide les mots clés en cours
255
				motsClesEnCours = "";
248
				motsClesEnCours = "" ;
256
				// pour chaque noeud à partir de la racine
249
				// pour chaque noeud à partir de la racine
257
				getArbreMotsCles().getRootNode().cascade(
-
 
258
						new NodeTraversalCallback() {
250
				getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
259
 
-
 
260
							// on éxécute une fonction
251
					
261
							public boolean execute(Node node) {
252
					// on éxécute une fonction
262
 
-
 
263
								// on récupère le mot clé associé au noeud et
253
					public boolean execute(Node node) {
264
								// ses infos
-
 
265
								TreeNode tn = getArbreMotsCles().getNodeById(
254
					
266
										node.getId());
255
							// on récupère le mot clé associé au noeud et ses infos
267
 
256
							TreeNode tn = getArbreMotsCles().getNodeById(node.getId()) ;
-
 
257
 
268
								String[] usObject = (String[]) tn
-
 
269
										.getUserObject();
258
								String[] usObject =  (String[])tn.getUserObject() ;
270
								GetIMediateur().mettreAjourMotsClesId(
259
								GetIMediateur().mettreAjourMotsClesId(usObject[0],usObject[1]) ;
271
										usObject[0], usObject[1]);
260
									
272
 
261
									if(tn.getUI().isChecked())
273
								if (tn.getUI().isChecked()) {
262
									{
274
									// et les concatène à la string des mots
263
										// et les concatène à la string des mots clés en cours
275
									// clés en cours
264
										motsClesEnCours += usObject[1]+"," ;
276
									motsClesEnCours += usObject[1] + ",";
265
									}
277
								}
266
							
278
 
-
 
279
								return true;
267
							return true ;
280
							}
-
 
281
 
268
					}
282
						});
269
					
283
 
270
				});
284
				// enfin on notifie le médiateur et on lui passe l'arbre et la
271
				
285
				// liste des mots clés ainsi obtenue
272
				// enfin on notifie le médiateur et on lui passe l'arbre et la liste des mots clés ainsi obtenue
286
				GetIMediateur().mettreAjourMotsCles(motsClesEnCours,
273
				GetIMediateur().mettreAjourMotsCles(motsClesEnCours,arbreMotsCles.getTree()) ;
287
						arbreMotsCles.getTree());
274
			}
288
			}
275
		}) ;
289
		});
276
		
290
 
277
	}
291
	}
278
	
292
 
279
	/**
293
	/**
280
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
294
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
Line 281... Line 295...
281
	 */
295
	 */
282
	public void obtenirArbreMotsCles() {
296
	public void obtenirArbreMotsCles() {
-
 
297
 
-
 
298
		GetIMediateur().obtenirArbreMotsCles(this);
283
		
299
 
284
		GetIMediateur().obtenirArbreMotsCles(this) ;
300
	}
285
		
301
 
286
	}
-
 
287
 
302
	/**
288
	/**
303
	 * Supprime un noeud de l'arbre
289
	 * Supprime un noeud de l'arbre
-
 
290
	 * @param n le noeud à supprimer
304
	 * 
291
	 */
305
	 * @param n
292
	public void supprimerNoeud(TreeNode n)
306
	 *            le noeud à supprimer
293
	{
307
	 */
-
 
308
	public void supprimerNoeud(TreeNode n) {
-
 
309
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
294
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
310
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
295
		if(!n.getId().equals(getArbreMotsCles().getRootNode().getId()))
-
 
296
		{
311
			// on détache le noeud et on le détruit
297
			// on détache le noeud et on le détruit
-
 
298
			n.getParentNode().removeChild(n);
312
			n.getParentNode().removeChild(n);
-
 
313
			n.destroy();
299
			n.destroy() ;
314
			// puis on en notifie le médiateur en lui passant le noeud supprimé
300
			// puis on en notifie le médiateur en lui passant le noeud supprimé et l'arbre
315
			// et l'arbre
301
			GetIMediateur().supprimerMotCleDansArbre(n, arbreMotsCles.getTree()) ;
316
			GetIMediateur()
302
		}
317
					.supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
303
		else
318
		} else {
304
		{
319
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
-
 
320
			// son erreur
-
 
321
			Window.alert("Impossible de supprimer la racine de l'arbre");
305
			// si l'utilisateur tente de supprimer la racine, on l'avertit de son erreur
322
		}
306
			Window.alert("Impossible de supprimer la racine de l'arbre") ;
323
	}
307
		}
324
 
308
	}
-
 
309
	
325
	/**
310
	/**
326
	 * Ajoute un noeud dans l'arbre au parent donné
311
	 * Ajoute un noeud dans l'arbre au parent donné
327
	 * 
312
	 * @param parent le futur parent du noeud à ajouter
328
	 * @param parent
313
	 */
329
	 *            le futur parent du noeud à ajouter
314
	public void ajouterNoeud(TreeNode parent)
330
	 */
315
	{
331
	public void ajouterNoeud(TreeNode parent) {
316
		
332
 
317
			// on met l'ajout du noeud à vrai
333
		// on met l'ajout du noeud à vrai
318
			ajoutNoeud = true ;
334
		ajoutNoeud = true;
319
			// on crée un nouveau noeud vide
335
		// on crée un nouveau noeud vide
320
			TreeNode nd = new TreeNode("");
336
		TreeNode nd = new TreeNode("");
321
			nd.setCls("x-view-treenode-keyword") ;
337
		nd.setCls("x-view-treenode-keyword");
322
			nd.setChecked(true);
338
		nd.setChecked(true);
323
			// on associe un objet au noeud qui contient des infos
339
		// on associe un objet au noeud qui contient des infos
324
			String[] usObject = new String[2] ;
340
		String[] usObject = new String[2];
325
			// l'objet contient le nom du noeud
341
		// l'objet contient le nom du noeud
326
			usObject[0] = "" ;
342
		usObject[0] = "";
327
			usObject[1] = genererIdMotCle(nd) ;
343
		usObject[1] = genererIdMotCle(nd);
328
			nd.setId(usObject[1]) ;
344
		nd.setId(usObject[1]);
329
			nd.setUserObject(usObject) ;
345
		nd.setUserObject(usObject);
-
 
346
		// l'identifiant d'un noeud c'est son hashcode
330
			// l'identifiant d'un noeud c'est son hashcode
347
		// l'objet associé au noeud contient aussi son identifiant
Line 331... Line -...
331
			// l'objet associé au noeud contient aussi son identifiant
-
 
332
			
348
 
333
			// on le concatène au parent et on étend ses enfants
349
		// on le concatène au parent et on étend ses enfants
334
			parent.appendChild(nd);
350
		parent.appendChild(nd);
335
			parent.expand() ;
351
		parent.expand();
-
 
352
		// enfin on place le curseur et on fait apparaitre le champ d'édition
336
			// enfin on place le curseur et on fait apparaitre le champ d'édition pour que l'utilisateur nomme son mot clé
353
		// pour que l'utilisateur nomme son mot clé
337
			te.startEdit(nd);
354
		te.startEdit(nd);
338
 
355
 
339
		
-
 
340
	}
356
	}
341
	
-
 
342
	/**
357
 
343
	 * Coche le noeud s'il est décoché, le décoche sinon
-
 
344
	 * @param node
358
	/**
345
	 */
-
 
346
	public void gererClicNoeud(TreeNode node)
359
	 * Coche le noeud s'il est décoché, le décoche sinon
347
	{
360
	 * 
348
		if(node.getUI().isChecked())
361
	 * @param node
349
		{
362
	 */
350
			node.getUI().toggleCheck(false) ;
363
	public void gererClicNoeud(TreeNode node) {
351
		}
364
		if (node.getUI().isChecked()) {
-
 
365
			node.getUI().toggleCheck(false);
-
 
366
		} else {
-
 
367
			node.getUI().toggleCheck(true);
352
		else
368
		}
353
		{
369
	}
354
			node.getUI().toggleCheck(true) ;
370
 
355
		}
-
 
-
 
371
	/**
356
	}
372
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
357
	
-
 
358
	/**
373
	 * clés à cocher
359
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots clés à cocher 
374
	 * 
-
 
375
	 * @param motsClesIds
360
	 * @param motsClesIds un tableau contenant les identifiants des mots clés à cocher
376
	 *            un tableau contenant les identifiants des mots clés à cocher
361
	 */
377
	 */
362
	public void cocherMotsCles(final String[] motsClesIds)
378
	public void cocherMotsCles(final String[] motsClesIds) {
363
	{
379
		if (getArbreMotsCles() != null
364
		if(getArbreMotsCles() != null && getArbreMotsCles().getRootNode() != null)
380
				&& getArbreMotsCles().getRootNode() != null) {
365
		{
381
			// à partir de la racine
366
			// à partir de la racine
-
 
367
			getArbreMotsCles().getRootNode().cascade(new NodeTraversalCallback() {
382
			getArbreMotsCles().getRootNode().cascade(
-
 
383
					new NodeTraversalCallback() {
368
	
384
 
-
 
385
						// pour chaque noeud
369
				// pour chaque noeud
386
						public boolean execute(Node node) {
370
				public boolean execute(Node node) {
387
 
371
					
388
							// on parcourt le tableau des mots clés
-
 
389
							for (int i = 0; i < motsClesIds.length; i++) {
-
 
390
								// si le mot clé fait partie des id à cocher on
-
 
391
								// le coche
372
						// on parcourt le tableau des mots clés
392
								String usObject[] = (String[]) node
-
 
393
										.getUserObject();
373
						for(int i = 0 ; i < motsClesIds.length ; i++)
394
								String nodeId = usObject[1];
374
						{
395
 
375
							// si le mot clé fait partie des id à cocher on le coche
396
								if (nodeId.equals(motsClesIds[i])) {
376
							String usObject[] = (String[])node.getUserObject() ;
-
 
377
							String nodeId = usObject[1] ;
397
									getArbreMotsCles().getNodeById(nodeId)
-
 
398
											.getUI().toggleCheck(true);
378
										
399
									return true;
379
							if(nodeId.equals(motsClesIds[i]))
-
 
380
							{
-
 
381
								getArbreMotsCles().getNodeById(nodeId).getUI().toggleCheck(true) ;
-
 
382
								return true ;
400
								}
383
							}
401
 
384
							
402
								getArbreMotsCles().getNodeById(node.getId())
385
							getArbreMotsCles().getNodeById(node.getId()).getUI().toggleCheck(false) ;
403
										.getUI().toggleCheck(false);
386
						}
404
							}
387
						// et on passe au suivant
405
							// et on passe au suivant
388
						return true;
406
							return true;
-
 
407
						}
-
 
408
 
389
				}
409
					});
-
 
410
		}
390
				
411
	}
391
			}) ;
412
 
392
		}
413
	/**
393
	}
414
	 * Méthode héritée de l'interface rafraichissable
394
	
415
	 * 
395
	/**
416
	 * @param nouvelleDonnees
396
	 * Méthode héritée de l'interface rafraichissable
-
 
397
	 * @param nouvelleDonnees les nouvelles données pour l'objet
417
	 *            les nouvelles données pour l'objet
398
	 * @param repandreRafraichissement booleen qui dit si on doit répandre l'évenement
418
	 * @param repandreRafraichissement
399
	 */
419
	 *            booleen qui dit si on doit répandre l'évenement
400
	public void rafraichir(Object nouvelleDonnees,
-
 
401
			boolean repandreRafraichissement) {
420
	 */
402
		// si on a reçu un arbre
421
	public void rafraichir(Object nouvelleDonnees,
403
		if(nouvelleDonnees instanceof Tree)
422
			boolean repandreRafraichissement) {
404
		{
423
		// si on a reçu un arbre
405
				Tree nouvelArbre = (Tree)nouvelleDonnees ;
424
		if (nouvelleDonnees instanceof Tree) {
406
				
425
			Tree nouvelArbre = (Tree) nouvelleDonnees;
407
				if(nouvelArbre.getRootNode().getChildNodes().length <= 0)
426
 
408
				{
427
			if (nouvelArbre.getRootNode().getChildNodes().length <= 0) {
409
					// on crée une racine pour l'arbre
428
				// on crée une racine pour l'arbre
410
					TreeNode root = new TreeNode("Tags") ;
429
				TreeNode root = new TreeNode("Tags");
411
					root.setId("racine") ;
430
				root.setId("racine");
412
					String[] usObject = {"Mots clés" , "racine" } ;
431
				String[] usObject = { "Mots clés", "racine" };
413
					root.setUserObject(usObject) ;
432
				root.setUserObject(usObject);
414
				}
433
			}
415
				
434
 
-
 
435
			// on prend sa racine et on l'attache à l'arbre des mots clés
416
					// on prend sa racine et on l'attache à l'arbre des mots clés
436
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
417
					Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes() ;
437
			for (int i = 0; i < rootChild.length; i++) {
418
					for (int i = 0; i < rootChild.length; i++) {
438
 
419
						
-
 
420
						rootChild[i].remove() ;
439
				rootChild[i].remove();
421
					}
440
			}
422
					
441
 
423
					getArbreMotsCles().getRootNode().appendChild(nouvelArbre.getRootNode()) ;
442
			getArbreMotsCles().getRootNode().appendChild(
424
						
443
					nouvelArbre.getRootNode());
425
					// si l'arbre n'était pas encore considéré comme instancié
444
 
426
					if(!estInstancie)
-
 
427
					{
445
			// si l'arbre n'était pas encore considéré comme instancié
428
						// on signale que oui
446
			if (!estInstancie) {
429
						estInstancie = true ;
447
				// on signale que oui
430
					}
448
				estInstancie = true;
431
					
449
			}
432
					// s'il y a des mots clés en attente (lors du premier rendering)
-
 
433
					if(motsCleInitialises == false && motsClesEnAttente != null)
450
 
434
					{
451
			// s'il y a des mots clés en attente (lors du premier rendering)
-
 
452
			if (motsCleInitialises == false && motsClesEnAttente != null) {
435
						// on les coche
453
				// on les coche
436
						//cocherMotsCles(motsClesEnAttente) ;
-
 
437
						motsCleInitialises = true ; 
454
				// cocherMotsCles(motsClesEnAttente) ;
438
					}
455
				motsCleInitialises = true;
439
		}
-
 
440
		
456
			}
-
 
457
		}
441
		
458
 
442
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une nouvelle image)
459
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
443
		if(nouvelleDonnees instanceof String[])
460
		// nouvelle image)
444
		{
461
		if (nouvelleDonnees instanceof String[]) {
445
			// et que l'arbre est instancié
462
			// et que l'arbre est instancié
446
			if(estInstancie && nouvelleDonnees != null)
463
			if (estInstancie && nouvelleDonnees != null) {
447
			{
464
				// le tableau de String contient les id des mots clés associés à
448
				// le tableau de String contient les id des mots clés associés à l'image
465
				// l'image
449
				// on coche les mots clés contenu dans le tableau
466
				// on coche les mots clés contenu dans le tableau
450
				String[] motsClesIds = (String[])nouvelleDonnees ;		
467
				String[] motsClesIds = (String[]) nouvelleDonnees;
451
				cocherMotsCles(motsClesIds) ;		
468
				cocherMotsCles(motsClesIds);
452
			}
469
			}
453
			// si l'arbre n'est pas encore instancié on met les mots clés en attente
470
			// si l'arbre n'est pas encore instancié on met les mots clés en
454
			else
-
 
455
			{
471
			// attente
456
				motsClesEnAttente = (String[])nouvelleDonnees ;
472
			else {
Line 457... Line 473...
457
			}
473
				motsClesEnAttente = (String[]) nouvelleDonnees;