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;