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

Subversion Repositories eFlore/Applications.cel

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