Subversion Repositories eFlore/Applications.cel

Rev

Rev 2231 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2042 aurelien 1
package org.tela_botanica.client.util;
2
 
3
import java.util.HashMap;
4
 
2166 aurelien 5
import org.tela_botanica.client.cel2;
6
 
2042 aurelien 7
import com.google.gwt.json.client.JSONArray;
8
import com.google.gwt.json.client.JSONObject;
9
import com.google.gwt.user.client.Window;
10
import com.gwtext.client.data.Node;
11
import com.gwtext.client.data.Tree;
12
import com.gwtext.client.widgets.tree.TreeNode;
13
 
14
public class MotsClesUtilitaire {
15
 
16
	//TODO rassembler tout ce qui construit les arbres de mots clés ici
2062 aurelien 17
	private static String[] caracteresInterdits = {"\\", "/", ","};
2042 aurelien 18
 
2194 mathias 19
	public static String obtenirCheminParent(String cheminMotCle) {
20
		String[] tabChemin = cheminMotCle.split("/");
21
		String cheminParent = "/";
22
		if(tabChemin.length >= 1) {
23
			for(int i = 1; i < tabChemin.length - 1; i++) {
24
				cheminParent += tabChemin[i]+"/";
25
			}
26
		}
27
		return cheminParent;
2042 aurelien 28
	}
29
 
30
	public static Object[] construireArbre(String NomRacine, String idRacine,
2062 aurelien 31
			JSONArray arbreJson, boolean afficherCheckbox) {
2042 aurelien 32
 
33
		Tree arbreMotsCles = new Tree() ;
34
		HashMap<String, String> motsCles = new HashMap<String, String>(0);
35
		HashMap<String, String> parentes = new HashMap<String, String>();
36
 
37
		final int taillemax = arbreJson.size();
38
 
39
		// on crée un arbre vide
40
		TreeNode root = new TreeNode();
41
		root.setId(idRacine);
42
		root.setText(NomRacine);
43
		String[] usObjRacine = {NomRacine, idRacine};
44
		root.setUserObject(usObjRacine);
45
		arbreMotsCles.setRootNode(root);
46
 
47
		// le mot clé racine possède le chemin racine ("/")
48
		parentes.put("/", idRacine);
49
 
50
		// pour chacun des élements du tableau
51
		for (int j = 0; j < taillemax; j++) {
52
			// on extrait les élements du tableau
53
			if (arbreJson.get(j).isObject() != null) {
54
				JSONObject noeud = (JSONObject) arbreJson.get(j);
55
 
56
				String idMotCle = noeud.get("id_mot_cle")
57
						.isString().stringValue();
58
				String motCle = noeud.get("mot_cle").isString()
59
						.stringValue();
2148 aurelien 60
 
61
				// le chemin est mis en minuscule afin de fusionner toutes
62
				// la variantes minuscules majuscule d'un mot clé
63
				// qui peuvent poser problème
2042 aurelien 64
				String chemin = noeud.get("chemin").isString()
2148 aurelien 65
						.stringValue().toLowerCase();
2042 aurelien 66
 
2194 mathias 67
				String cheminParent = MotsClesUtilitaire.obtenirCheminParent(chemin);
2042 aurelien 68
				String parent = parentes.get(cheminParent);
69
 
70
				String[] usObj = {motCle, idMotCle};
71
 
72
				// et on construit l'arbre en ajoutant les noeuds un à un (qui sont renvoyés
73
				// dans l'ordre hierarchique de leur niveau
74
				// ce qui permet de les traiter séquentiellement)
75
				TreeNode node = new TreeNode();
76
				node.setId(idMotCle);
77
				node.setText(motCle);
2062 aurelien 78
				if(afficherCheckbox) {
79
					node.setChecked(false);
80
				}
2148 aurelien 81
 
2042 aurelien 82
				Node parentNode = arbreMotsCles.getNodeById(parent);
83
				node.setUserObject(usObj);
84
				parentNode.appendChild(node);
85
 
86
				parentes.put(chemin, idMotCle);
87
				motsCles.put(idMotCle, motCle);
88
			}
89
		}
90
		Object[] retour = {arbreMotsCles, motsCles};
91
		return retour;
92
	}
93
 
94
	/**
95
	 * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un
96
	 * copie du sous arbre du premier noeud, qu'elle concatène au deuxième
97
	 *
98
	 * @param ndPereOriginal
99
	 *            le père des noeuds de l'arbre original
100
	 * @param ndPereCopie
101
	 *            le père qui va recevoir les copies
102
	 */
2062 aurelien 103
	public static void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie, boolean afficherCheckbox) {
2042 aurelien 104
		if (ndPereCopie != null && ndPereOriginal != null) {
105
			Node[] ndNodeFils = ndPereOriginal.getChildNodes();
106
 
107
			for (int i = 0; i < ndNodeFils.length; i++) {
2166 aurelien 108
 
2042 aurelien 109
				String[] usObj = (String[]) ndNodeFils[i].getUserObject();
110
				TreeNode child = new TreeNode(usObj[0]);
111
				child.setId(usObj[1]);
2062 aurelien 112
				if(afficherCheckbox) {
113
					child.setChecked(false);
114
				}
2042 aurelien 115
				child.setUserObject(usObj);
116
				ndPereCopie.appendChild(child);
117
 
118
				if (!ndNodeFils[i].isLeaf()) {
2062 aurelien 119
					copierFilsNoeud(ndNodeFils[i], child, afficherCheckbox);
2042 aurelien 120
				}
121
			}
122
		}
123
	}
2062 aurelien 124
 
125
	public static TreeNode ajouterNoeud(TreeNode parent, boolean afficherCheckbox) {
126
		// on crée un nouveau noeud vide
127
		TreeNode nd = new TreeNode("");
128
		nd.setCls("x-view-treenode-keyword");
129
 
130
		if(afficherCheckbox) {
131
			nd.setChecked(true);
132
		}
133
 
134
		// on associe un objet au noeud qui contient des infos
135
		String[] usObject = new String[2];
136
		// l'objet contient le nom du noeud
137
		usObject[0] = "";
138
		usObject[1] = "";
139
		nd.setUserObject(usObject);
140
 
141
		String cheminTemporaireAjout = parent.getPath()+"/"+nd.getId();
142
		nd.setId(cheminTemporaireAjout);
143
 
144
		return nd;
145
	}
146
 
147
	public static String getChaineCaracteresInterdits() {
148
		String interdits = "";
149
		for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
150
			interdits += MotsClesUtilitaire.caracteresInterdits[i]+" ";
151
		}
152
		return interdits;
153
	}
154
 
155
	public static boolean estUnMotCleAutorise(String motCle) {
156
		boolean valide = !motCle.trim().isEmpty();
157
		for (int i = 0; i < MotsClesUtilitaire.caracteresInterdits.length; i++) {
158
			if(motCle.indexOf(MotsClesUtilitaire.caracteresInterdits[i]) != -1) {
159
				valide = false;
160
				break;
161
			}
162
		}
163
		return valide;
164
	}
2194 mathias 165
 
166
	public static boolean estUnePositionAutorisee(TreeNode node, Node parent, String text) {
167
		if(parent == null) {
168
			parent = node.getParentNode();
169
		}
2231 mathias 170
		text = normaliserChaine(text);
2194 mathias 171
		Node[] noeudsFreres = parent.getChildNodes();
172
		boolean ok = true;
173
		for(int i = 0; i <= noeudsFreres.length; i++) {
174
			if(noeudsFreres[i] != null) {
2231 mathias 175
				String cheminFrere = normaliserChaine(noeudsFreres[i].getPath());
176
				String cheminNoeud = normaliserChaine(node.getPath());
177
				String texteNoeudfrere = normaliserChaine(((String[])noeudsFreres[i].getUserObject())[0]);
178
				if(!cheminFrere.equals(cheminNoeud) && text.equals(texteNoeudfrere)) {
2194 mathias 179
					ok = false;
180
				}
181
			}
182
		}
183
		return ok;
184
	}
2231 mathias 185
 
186
	public static String normaliserChaine(String chaine) {
187
		return supprimerAccents(chaine).toLowerCase().trim();
188
	}
189
 
190
	public static String supprimerAccents(String chaine) {
191
	    String s = chaine;
192
 
193
	    s = s.replaceAll("[èéêë]","e");
194
	    s = s.replaceAll("[ûùü]","u");
195
	    s = s.replaceAll("[ïî]","i");
196
	    s = s.replaceAll("[àâ]","a");
197
	    s = s.replaceAll("ô","o");
198
 
199
	    s = s.replaceAll("[ÈÉÊË]","E");
200
	    s = s.replaceAll("[ÛÙÜ]","U");
201
	    s = s.replaceAll("[ÏÎ]","I");
202
	    s = s.replaceAll("[ÀÂ]","A");
203
	    s = s.replaceAll("Ô","O");
204
 
205
	    return s;
206
	}
2042 aurelien 207
}