WebSVN – eFlore/Applications.cel – Diff – /branches/v1.6-croc/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java


package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.NodeTraversalCallback;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.VerticalLayout;
import com.gwtext.client.widgets.tree.TreeEditor;
import com.gwtext.client.widgets.tree.TreeNode;
import com.gwtext.client.widgets.tree.TreePanel;
import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter;
 
/**
 * Arbre des mots clés, qui est une vue rafraichissable, qui contient des mots
 * clés cochables et réorganisables à volonté
 * 
 * @author aurelien
 * 
 */
public class ArbreMotsClesVue extends Panel implements Rafraichissable {
 
	/**
	 * Le médiateur associé à la vue
	 */
	private ImageMediateur iMediateur = null;
 
	/**
	 * Le treepanel qui affiche l'arbre
	 */
	private TreePanel arbreMotsCles = null;
	/**
	 * L'éditeur qui permet de modifier les mots clés dans l'arbre
	 */
	private TreeEditor te = null;
	/**
	 * Le textfield associé à l'éditeur
	 */
	private TextField tfEdit = null;
	/**
	 * Bouton de validation
	 */
	private Button valider = null;
	/**
	 * Une string permettant connaitre les mots clés cochés en cours séparés par
	 * des virgules
	 */
	private String motsClesEnCours = "";
	
	private String[] tableauMotsClesEnCours = new String[0];
	/**
	 * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre
	 * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu
	 * du conteneur n'ai été effectué)
	 */
	private String[] motsClesEnAttente = new String[0];
	/**
	 * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un
	 * noeud
	 */
	private boolean ajoutNoeud = false;
	/**
	 * Booléen d'évènement qui sert à savoir si on est en train de modifier un
	 * noeud
	 */
	private boolean modifNoeud = false;
	/**
	 * Booléen d'instanciation du conteneur
	 */
	private boolean arbreCharge = false;
	/**
	 * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu
	 */
	private boolean motsCleInitialises;
 
	/**
	 * Constructeur sans paramètre (privé car interdit d'utilisation)
	 */
	@SuppressWarnings("unused")
	private ArbreMotsClesVue() {
		super();
	}
 
	/**
	 * Constructeur avec paramètre
	 * 
	 * @param im
	 *            le médiateur à associer
	 */
	public ArbreMotsClesVue(ImageMediateur im) {
		// on crée le panel
		super("Mots clés");
		this.setLayout(new VerticalLayout());
		iMediateur = im;
 
		// on crée le conteneur de l'arbre
		arbreMotsCles = new TreePanel();
		// on permet le drag and drop dans l'arbre
		arbreMotsCles.setEnableDD(true);
		arbreMotsCles.setId("x-view-tree-keyword");
 
		// on crée une racine pour l'arbre
		TreeNode root = new TreeNode("Tags");
		root.setId("racine");
		String[] usObject = { "Mots clés", "racine" };
		root.setUserObject(usObject);
		arbreMotsCles.setRootNode(root);
		arbreMotsCles.setRootVisible(true);
		arbreMotsCles.setBorder(false);
		arbreMotsCles.setWidth(500);
 
		// on crée l'éditeur pour l'arbre
		tfEdit = new TextField();
		tfEdit.setAutoWidth(true);
		te = new TreeEditor(arbreMotsCles, tfEdit);
		valider = new Button("Appliquer");
		arbreMotsCles.add(te);
 
		// on met en forme le layout
		this.add(arbreMotsCles);
		this.add(valider);
 
		this.setBorder(false);
		this.setCollapsible(true);
		this.setTitleCollapse(true);
		
		// on ajoute les listeners
		ajouterListeners();
 
	}
 
	/**
	 * Acesseur pour le médiateur
	 * 
	 * @return le médiateur associé à la vue
	 */
	private ImageMediateur getIMediateur() {
 
		return iMediateur;
 
	}
 
	/**
	 * Acesseur pour l'arbre des mots clés
	 * 
	 * @return le panel contenant l'arbre
	 */
	public TreePanel getArbreMotsCles() {
		return arbreMotsCles;
	}
 
	/**
	 * Accesseur pour l'éditeur
	 * 
	 * @return l'éditeur associé à l'arbre
	 */
	public TreeEditor getTe() {
		return te;
	}
 
	/**
	 * Acesseur pour le TextField associé à l'éditeur
	 * 
	 * @return le champ texte associé à l'éditeur
	 */
	public TextField getTfEdit() {
		return tfEdit;
	}
 
	/**
	 * Ajoute les listeners nécessaires pour la gestion des évènements
	 */
	private void ajouterListeners() {
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
 
			public void onExpandNode(TreeNode node) {		
				cocherMotsCles(tableauMotsClesEnCours);
			}
			
			// gestion du clic sur un noeud
			public void onClick(TreeNode node, EventObject e) {
 
				e.stopEvent();
				gererClicNoeud(node);
			}
 
			// gestion du clic droit sur un noeud
			public void onContextMenu(TreeNode node, EventObject e) {
 
				e.stopEvent();
				getIMediateur().montrerContextMenuArbre(node, e, getTe());
 
			}
 
			// gestion du double clic sur un noeud
			public void onDblClick(TreeNode node, EventObject e) {
 
				modifNoeud = true;
				if (!node.getId().equals("racine")) {
					te.startEdit(node);
				}
			}
 
			// gestion de la modification du texte d'un noeud
			public void onTextChange(TreeNode node, String text, String oldText) {
 
				// on récupère les informations associées au noeud
				TreeNode nd = node;
				String[] usObject = new String[2];
				usObject[0] = text;
				usObject[1] = ((String[]) nd.getUserObject())[1];
				nd.setUserObject(usObject);
 
				// si c'est un nouveau noeud
				if (ajoutNoeud) {
					// on considère l'ajout achevé
					ajoutNoeud = false;
					// et on notifie le médiateur de l'ajout et on lui passe
					// l'arbre
					getIMediateur().ajouterMotCleDansArbre(nd,
							getArbreMotsCles().getTree());
				}
				// si c'est noeud déjà existant
				else {
					// et on considère la modification achevée
					modifNoeud = false;
					// on notifie le médiateur de la modification et on lui
					// passe l'arbre
					getIMediateur().modifierMotCleDansArbre(nd,
							getArbreMotsCles().getTree());
				}
 
			}
 
			// gestion du déplacement d'un noeud
			public void onMoveNode(Tree tree, TreeNode node,
					TreeNode oldParent, TreeNode newParent, int index) {
				// on notifie le médiateur et on lui passe l'arbre
				getIMediateur().deplacerMotCleDansArbre(node,
						getArbreMotsCles().getTree());
			}
 
		});
 
		// gestion de la validation
		valider.addListener(new ButtonListenerAdapter() {
 
			// lors du clic
			public void onClick(Button button, EventObject e) {
 
				// on vide les mots clés en cours
				motsClesEnCours = "";
				// pour chaque noeud à partir de la racine
				getArbreMotsCles().getRootNode().cascade(
						new NodeTraversalCallback() {
 
							// on éxécute une fonction
							public boolean execute(Node node) {
 
								// on récupère le mot clé associé au noeud et
								// ses infos
								TreeNode tn = getArbreMotsCles().getNodeById(
										node.getId());
 
								String[] usObject = (String[]) tn
										.getUserObject();
								getIMediateur().mettreAjourMotsClesId(
										usObject[0], usObject[1]);
 
								if (tn.getUI().isChecked()) {
									// et les concatène à la string des mots
									// clés en cours
									motsClesEnCours += usObject[1] + ",";
								}
 
								return true;
							}
 
						});
 
				// enfin on notifie le médiateur et on lui passe l'arbre et la
				// liste des mots clés ainsi obtenue
				getIMediateur().mettreAjourMotsCles(motsClesEnCours,
						arbreMotsCles.getTree());
			}
		});
 
 
 
 
 
 
 
 
 
 
	}
 
	/**
	 * Envoie une demande au médiateur pour obtenir l'arbre des mots clés
	 */
	public void obtenirArbreMotsCles() {
 
		getIMediateur().obtenirArbreMotsCles(this);
 
	}
 
	/**
	 * Supprime un noeud de l'arbre
	 * 
	 * @param n
	 *            le noeud à supprimer
	 */
	public void supprimerNoeud(TreeNode n) {
		// si ça n'est pas la racine (qu'on ne peut pas supprimer)
		if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) {
			// on détache le noeud et on le détruit
			n.getParentNode().removeChild(n);
			n.destroy();
			// puis on en notifie le médiateur en lui passant le noeud supprimé
			// et l'arbre
			getIMediateur()
					.supprimerMotCleDansArbre(n, arbreMotsCles.getTree());
		} else {
			// si l'utilisateur tente de supprimer la racine, on l'avertit de
			// son erreur
			Window.alert("Impossible de supprimer la racine de l'arbre");
		}
	}
 
	/**
	 * Ajoute un noeud dans l'arbre au parent donné
	 * 
	 * @param parent
	 *            le futur parent du noeud à ajouter
	 */
	public void ajouterNoeud(TreeNode parent) {
 
		// on met l'ajout du noeud à vrai
		ajoutNoeud = true;
		// on crée un nouveau noeud vide
		TreeNode nd = new TreeNode("");
		nd.setCls("x-view-treenode-keyword");
		nd.setChecked(true);
		// on associe un objet au noeud qui contient des infos
		String[] usObject = new String[2];
		// l'objet contient le nom du noeud
		usObject[0] = "";
		usObject[1] = genererIdMotCle(nd);
		nd.setId(usObject[1]);
		nd.setUserObject(usObject);
		// l'identifiant d'un noeud c'est son hashcode
		// l'objet associé au noeud contient aussi son identifiant
 
		// on le concatène au parent et on étend ses enfants
		parent.appendChild(nd);
		parent.expand();
		// enfin on place le curseur et on fait apparaitre le champ d'édition
		// pour que l'utilisateur nomme son mot clé
		te.startEdit(nd);
 
	}
 
	/**
	 * Coche le noeud s'il est décoché, le décoche sinon
	 * 
	 * @param node
	 */
	public void gererClicNoeud(TreeNode node) {
		if (node.getUI().isChecked()) {
			node.getUI().toggleCheck(false);
		} else {
			node.getUI().toggleCheck(true);
		}
	}
 
	/**
	 * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots
	 * clés à cocher
	 * 
	 * @param motsClesIds
	 *            un tableau contenant les identifiants des mots clés à cocher
	 */
	public void cocherMotsCles(final String[] motsClesIds) {
		if (getArbreMotsCles() != null
				&& getArbreMotsCles().getRootNode() != null) {
			// à partir de la racine
			getArbreMotsCles().getRootNode().cascade(
					new NodeTraversalCallback() {
 
						// pour chaque noeud
						public boolean execute(Node node) {
 
							getArbreMotsCles().getNodeById(node.getId())
							.getUI().toggleCheck(false);
							
							// on parcourt le tableau des mots clés
							for (int i = 0; i < motsClesIds.length; i++) {
								// si le mot clé fait partie des id à cocher on
								// le coche
								String usObject[] = (String[]) node
										.getUserObject();
								String nodeId = usObject[1];
 
								if (nodeId.equals(motsClesIds[i])) {
									getArbreMotsCles().getNodeById(nodeId)
											.getUI().toggleCheck(true);
									return true;
								}
							}
							// et on passe au suivant
							return true;
						}
 
					});
		}
	}
 
	/**
	 * Méthode héritée de l'interface rafraichissable
	 * 
	 * @param nouvelleDonnees
	 *            les nouvelles données pour l'objet
	 * @param repandreRafraichissement
	 *            booleen qui dit si on doit répandre l'évenement
	 */
	public void rafraichir(Object nouvelleDonnees,
			boolean repandreRafraichissement) {
		
		if(nouvelleDonnees instanceof Tree) {
 
			Tree nouvelArbre = (Tree)nouvelleDonnees ;
 
			// on prend sa racine et on l'attache à l'arbre des mots clés
			Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes();
			for (int i = 0; i < rootChild.length; i++) {
				
				rootChild[i].remove();
			}
			
			copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode());
 
			// si l'arbre n'était pas encore considéré comme instancié
			if (!arbreCharge) {
				// on signale que oui
				arbreCharge = true;
			}
 
 
 
 
 
 
 
 
 
 
 
		}
 
		// Si on reçoit un tableau de String (cas ou l'on séléectionne une
		// nouvelle image)
		if (nouvelleDonnees instanceof String[]) {
 
 
 
				// le tableau de String contient les id des mots clés associés à
				// l'image
				// on coche les mots clés contenu dans le tableau
				tableauMotsClesEnCours = (String[]) nouvelleDonnees;
				cocherMotsCles(tableauMotsClesEnCours);
 
 
 
 
 
 
 
 
 
		}
	}
 
	private String genererIdMotCle(TreeNode nd) {
		return "" + (nd.hashCode() + (Math.random() * 10000));
	}
	
	/**
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
	 * 
	 * @param ndPereOriginal
	 *            le père des noeuds de l'arbre original
	 * @param ndPereCopie
	 *            le père qui va recevoir les copies
	 */
	private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
		if (ndPereCopie != null && ndPereOriginal != null) {
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
			
			for (int i = 0; i < ndNodeFils.length; i++) {
 
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
				TreeNode child = new TreeNode(usObj[0]);
				child.setId(usObj[1]);
				child.setChecked(false);
				child.setUserObject(usObj);
				ndPereCopie.appendChild(child);
 
				if (!ndNodeFils[i].isLeaf()) {
					copierFilsNoeud(ndNodeFils[i], child);
				}
 
			}
		}
	}
}

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

Subversion Repositories eFlore/Applications.cel

(root)/branches/v1.6-croc/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java @ 3220 – Rev 1007 → 1009