Subversion Repositories eFlore/Applications.cel

Rev

Rev 2042 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2042 Rev 2062
1 
package org.tela_botanica.client.util;
 1 
package org.tela_botanica.client.util;
2 
 
 2 
 
3 
import java.util.HashMap;
 3 
import java.util.HashMap;
4 
 
 4 
 
5 
import com.google.gwt.json.client.JSONArray;
 5 
import com.google.gwt.json.client.JSONArray;
6 
import com.google.gwt.json.client.JSONObject;
 6 
import com.google.gwt.json.client.JSONObject;
7 
import com.google.gwt.user.client.Window;
 7 
import com.google.gwt.user.client.Window;
8 
import com.gwtext.client.data.Node;
 8 
import com.gwtext.client.data.Node;
9 
import com.gwtext.client.data.Tree;
 9 
import com.gwtext.client.data.Tree;
10 
import com.gwtext.client.widgets.tree.TreeNode;
 10 
import com.gwtext.client.widgets.tree.TreeNode;
11 
 
 11 
 
12 
public class MotsClesUtilitaire {
 12 
public class MotsClesUtilitaire {
13
13
14 
	//TODO rassembler tout ce qui construit les arbres de mots clés ici
 14 
	//TODO rassembler tout ce qui construit les arbres de mots clés ici
- 
 
 15 
	private static String[] caracteresInterdits = {"\\", "/", ","};
15
16
16 
	public static String obtenirCheminParent(String cheminMotCle, String motCle) {
 17 
	public static String obtenirCheminParent(String cheminMotCle, String motCle) {
17 
		return cheminMotCle.substring(0, cheminMotCle.length() - motCle.length() -1);
 18 
		return cheminMotCle.substring(0, cheminMotCle.length() - motCle.length() -1);
18 
	}
 19 
	}
19 
 
 20 
 
20 
	public static Object[] construireArbre(String NomRacine, String idRacine,
 21 
	public static Object[] construireArbre(String NomRacine, String idRacine,
21 
			JSONArray arbreJson) {
 22 
			JSONArray arbreJson, boolean afficherCheckbox) {
22
23
23 
		Tree arbreMotsCles = new Tree() ;
24 
		Tree arbreMotsCles = new Tree() ;
24 
		HashMap<String, String> motsCles = new HashMap<String, String>(0);
 25 
		HashMap<String, String> motsCles = new HashMap<String, String>(0);
25 
		HashMap<String, String> parentes = new HashMap<String, String>();
 26 
		HashMap<String, String> parentes = new HashMap<String, String>();
26
27
27 
		final int taillemax = arbreJson.size();
 28 
		final int taillemax = arbreJson.size();
28 
 
 29 
 
29 
		// on crée un arbre vide
 30 
		// on crée un arbre vide
30 
		TreeNode root = new TreeNode();
 31 
		TreeNode root = new TreeNode();
31 
		root.setId(idRacine);
 32 
		root.setId(idRacine);
32 
		root.setText(NomRacine);
 33 
		root.setText(NomRacine);
33 
		String[] usObjRacine = {NomRacine, idRacine};
 34 
		String[] usObjRacine = {NomRacine, idRacine};
34 
		root.setUserObject(usObjRacine);
 35 
		root.setUserObject(usObjRacine);
35 
		arbreMotsCles.setRootNode(root);
 36 
		arbreMotsCles.setRootNode(root);
36
37
37 
		// le mot clé racine possède le chemin racine ("/")
 38 
		// le mot clé racine possède le chemin racine ("/")
38 
		parentes.put("/", idRacine);
 39 
		parentes.put("/", idRacine);
39 
 
 40 
 
40 
		// pour chacun des élements du tableau
 41 
		// pour chacun des élements du tableau
41 
		for (int j = 0; j < taillemax; j++) {
 42 
		for (int j = 0; j < taillemax; j++) {
42 
			// on extrait les élements du tableau
 43 
			// on extrait les élements du tableau
43 
			if (arbreJson.get(j).isObject() != null) {
 44 
			if (arbreJson.get(j).isObject() != null) {
44 
				JSONObject noeud = (JSONObject) arbreJson.get(j);
 45 
				JSONObject noeud = (JSONObject) arbreJson.get(j);
45 
 
 46 
 
46 
				String idMotCle = noeud.get("id_mot_cle")
 47 
				String idMotCle = noeud.get("id_mot_cle")
47 
						.isString().stringValue();
 48 
						.isString().stringValue();
48 
				String motCle = noeud.get("mot_cle").isString()
 49 
				String motCle = noeud.get("mot_cle").isString()
49 
						.stringValue();
 50 
						.stringValue();
50 
				String chemin = noeud.get("chemin").isString()
 51 
				String chemin = noeud.get("chemin").isString()
51 
						.stringValue();
 52 
						.stringValue();
52
53
53 
				String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin, motCle);
 54 
				String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin, motCle);
54 
				String parent = parentes.get(cheminParent);
 55 
				String parent = parentes.get(cheminParent);
55
56
56 
				String[] usObj = {motCle, idMotCle};
 57 
				String[] usObj = {motCle, idMotCle};
57 
 
 58 
 
58 
				// et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés
 59 
				// et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés
59 
				// dans l'ordre hierarchique de leur niveau
 60 
				// dans l'ordre hierarchique de leur niveau
60 
				// ce qui permet de les traiter séquentiellement)
 61 
				// ce qui permet de les traiter séquentiellement)
61 
				TreeNode node = new TreeNode();
 62 
				TreeNode node = new TreeNode();
62 
				node.setId(idMotCle);
 63 
				node.setId(idMotCle);
63 
				node.setText(motCle);
 64 
				node.setText(motCle);
- 
 
 65 
				if(afficherCheckbox) {
64 
				node.setChecked(false);
 66 
					node.setChecked(false);
- 
 
 67 
				}
65 
				Node parentNode = arbreMotsCles.getNodeById(parent);
 68 
				Node parentNode = arbreMotsCles.getNodeById(parent);
66 
				node.setUserObject(usObj);
 69 
				node.setUserObject(usObj);
67 
				parentNode.appendChild(node);
 70 
				parentNode.appendChild(node);
68
71
69 
				parentes.put(chemin, idMotCle);
 72 
				parentes.put(chemin, idMotCle);
70 
				motsCles.put(idMotCle, motCle);
 73 
				motsCles.put(idMotCle, motCle);
71 
			}
 74 
			}
72 
		}
 75 
		}
73 
		Object[] retour = {arbreMotsCles, motsCles};
 76 
		Object[] retour = {arbreMotsCles, motsCles};
74 
		return retour;
 77 
		return retour;
75 
	}
 78 
	}
76 
 
 - 
 
77 
	public static String construireChemin(TreeNode nd) {
 - 
 
78 
		String chemin = "/";
 - 
 
79 
		Node node = nd;
 - 
 
80 
		while(node != null) {
 - 
 
81 
			String[] usObj = (String[])node.getUserObject();
 - 
 
82 
			chemin = usObj[0]+"/"+chemin;
 - 
 
83 
			node = node.getParentNode();
 - 
 
84 
		}
 - 
 
85 
		return chemin;
 - 
 
86 
	}
 - 
 
87 
 
 79 
 
88 
	/**
 80 
	/**
89 
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
 81 
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
90 
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
 82 
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
91 
	 *
83 
	 *
92 
	 * @param ndPereOriginal
 84 
	 * @param ndPereOriginal
93 
	 *            le père des noeuds de l'arbre original
 85 
	 *            le père des noeuds de l'arbre original
94 
	 * @param ndPereCopie
 86 
	 * @param ndPereCopie
95 
	 *            le père qui va recevoir les copies
 87 
	 *            le père qui va recevoir les copies
96 
	 */
 88 
	 */
97 
	public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) {
 89 
	public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie, boolean afficherCheckbox) {
98 
		if (ndPereCopie != null && ndPereOriginal != null) {
 90 
		if (ndPereCopie != null && ndPereOriginal != null) {
99 
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
 91 
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
100
92
101 
			for (int i = 0; i < ndNodeFils.length; i++) {
 93 
			for (int i = 0; i < ndNodeFils.length; i++) {
102 
 
 94 
 
103 
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
 95 
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
104 
				TreeNode child = new TreeNode(usObj[0]);
 96 
				TreeNode child = new TreeNode(usObj[0]);
105 
				child.setId(usObj[1]);
 97 
				child.setId(usObj[1]);
- 
 
 98 
				if(afficherCheckbox) {
106 
				child.setChecked(false);
 99 
					child.setChecked(false);
- 
 
 100 
				}
107 
				child.setUserObject(usObj);
 101 
				child.setUserObject(usObj);
108 
				ndPereCopie.appendChild(child);
 102 
				ndPereCopie.appendChild(child);
109 
 
 103 
 
110 
				if (!ndNodeFils[i].isLeaf()) {
 104 
				if (!ndNodeFils[i].isLeaf()) {
111 
					copierFilsNoeud(ndNodeFils[i], child);
 105 
					copierFilsNoeud(ndNodeFils[i], child, afficherCheckbox);
112 
				}
 106 
				}
113 
			}
 107 
			}
114 
		}
 108 
		}
115 
	}
 109 
	}
- 
 
 110
- 
 
 111 
	public static TreeNode ajouterNoeud(TreeNode parent, boolean afficherCheckbox) {
- 
 
 112 
		// on crée un nouveau noeud vide
- 
 
 113 
		TreeNode nd = new TreeNode("");
- 
 
 114 
		nd.setCls("x-view-treenode-keyword");
- 
 
 115
- 
 
 116 
		if(afficherCheckbox) {
- 
 
 117 
			nd.setChecked(true);
- 
 
 118 
		}
- 
 
 119
- 
 
 120 
		// on associe un objet au noeud qui contient des infos
- 
 
 121 
		String[] usObject = new String[2];
- 
 
 122 
		// l'objet contient le nom du noeud
- 
 
 123 
		usObject[0] = "";
- 
 
 124 
		usObject[1] = "";
- 
 
 125 
		nd.setUserObject(usObject);
- 
 
 126
- 
 
 127 
		String cheminTemporaireAjout = parent.getPath()+"/"+nd.getId();
- 
 
 128 
		nd.setId(cheminTemporaireAjout);
- 
 
 129
- 
 
 130 
		return nd;
- 
 
 131 
	}
- 
 
 132
- 
 
 133 
	public static String getChaineCaracteresInterdits() {
- 
 
 134 
		String interdits = "";
- 
 
 135 
		for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
- 
 
 136 
			interdits += MotsClesUtilitaire.caracteresInterdits[i]+" ";
- 
 
 137 
		}
- 
 
 138 
		return interdits;
- 
 
 139 
	}
- 
 
 140
- 
 
 141 
	public static boolean estUnMotCleAutorise(String motCle) {
- 
 
 142 
		boolean valide = !motCle.trim().isEmpty();
- 
 
 143 
		for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
- 
 
 144 
			if(motCle.indexOf(MotsClesUtilitaire.caracteresInterdits[i]) != -1) {
- 
 
 145 
				valide = false;
- 
 
 146 
				break;
- 
 
 147 
			}
- 
 
 148 
		}
- 
 
 149 
		return valide;
- 
 
 150 
	}
116 
}
 151 
}