WebSVN – eFlore/Applications.cel – Diff – /trunk/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 org.tela_botanica.client.util.MotsClesUtilitaire;
 
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;
 
	private String cheminTemporaireAjout;
 
	/**
	 * 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() {
		
		final Rafraichissable r = this;
		arbreMotsCles.addListener(new TreePanelListenerAdapter() {
 
			@Override
			public void onExpandNode(TreeNode node) {		
				cocherMotsCles(tableauMotsClesEnCours);
			}
			
			// gestion du clic sur un noeud
			@Override
			public void onClick(TreeNode node, EventObject e) {
				e.stopEvent();
				gererClicNoeud(node);
			}
 
			// gestion du clic droit sur un noeud
			@Override
			public void onContextMenu(TreeNode node, EventObject e) {
				e.stopEvent();
				getIMediateur().montrerContextMenuArbre(node, e, getTe());
			}
 
			// gestion du double clic sur un noeud
			@Override
			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
			@Override
			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(), r);
				}
				// 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
			@Override
			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
			@Override
			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
							@Override
							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] = "";
		cheminTemporaireAjout = MotsClesUtilitaire.construireChemin(nd);
		usObject[1] = cheminTemporaireAjout;
		nd.setId(cheminTemporaireAjout);
		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
						@Override
						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
	 */
	@Override
	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();
			}
			
			MotsClesUtilitaire.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);
		}
 
		
 
 
 
 
 
 
 
 
 
		// reception d'un nouvel identifiant de mot clé
 
		if(nouvelleDonnees instanceof Integer) {
 
 
			if(cheminTemporaireAjout != null) {
				String id = ((Integer)(nouvelleDonnees)).toString();
 
				TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout);
 
				String[] userObj = {noeudEnAjout.getText(), id};
 
 
 
				noeudEnAjout.setUserObject(userObj);
				noeudEnAjout.setId(id);
 
 
				cheminTemporaireAjout = null;
 
 
			}
		}
		
		arbreMotsCles.enable();
	}
}

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

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/ArbreMotsClesVue.java – Rev 1291 → 2042