Subversion Repositories eFlore/Applications.coel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
936 jpm 1
package org.tela_botanica.client.vues;
453 jp_milcent 2
 
3
import java.util.ArrayList;
4
import java.util.HashMap;
5
import java.util.Iterator;
6
 
7
import org.tela_botanica.client.ComposantClass;
8
import org.tela_botanica.client.Mediateur;
813 jpm 9
import org.tela_botanica.client.RegistreId;
907 jpm 10
import org.tela_botanica.client.configuration.Configuration;
453 jp_milcent 11
import org.tela_botanica.client.i18n.Constantes;
12
import org.tela_botanica.client.interfaces.Rafraichissable;
13
import org.tela_botanica.client.modeles.Valeur;
14
import org.tela_botanica.client.modeles.ValeurListe;
961 jpm 15
import org.tela_botanica.client.modeles.aDonnee;
1322 gduche 16
import org.tela_botanica.client.synchronisation.Sequenceur;
967 jpm 17
import org.tela_botanica.client.util.Debug;
819 gduche 18
import org.tela_botanica.client.util.UtilString;
453 jp_milcent 19
 
813 jpm 20
import com.extjs.gxt.ui.client.Registry;
453 jp_milcent 21
import com.extjs.gxt.ui.client.Style.Scroll;
22
import com.extjs.gxt.ui.client.util.Format;
23
import com.extjs.gxt.ui.client.util.Params;
24
import com.extjs.gxt.ui.client.widget.HtmlContainer;
25
import com.extjs.gxt.ui.client.widget.LayoutContainer;
26
import com.extjs.gxt.ui.client.widget.TabItem;
27
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
28
import com.google.gwt.core.client.GWT;
29
 
30
public abstract class DetailVue extends LayoutContainer implements Rafraichissable {
31
 
32
	protected Mediateur mediateur = null;
33
	protected Constantes i18nC = null;
34
 
35
	protected HashMap<String, Valeur> ontologie = null;
813 jpm 36
	protected boolean ontologieChargementOk = false;
37
	private HashMap<Integer, String> ontologiesEnAttenteDeReception = null;
38
 
453 jp_milcent 39
	protected String sautLigneTpl = null;
40
 
41
	public DetailVue(Mediateur mediateurCourant) {
42
		mediateur = mediateurCourant;
602 jp_milcent 43
		i18nC = Mediateur.i18nC;
453 jp_milcent 44
 
45
		initialiserSautLigneTpl();
46
 
47
		ontologie = new HashMap<String, Valeur>();
813 jpm 48
		ontologieChargementOk = false;
49
		ontologiesEnAttenteDeReception = new HashMap<Integer, String>();
453 jp_milcent 50
 
51
		setLayout(new FitLayout());
52
		setBorders(false);
53
		setScrollMode(Scroll.AUTO);
54
	}
55
 
56
	private void initialiserSautLigneTpl() {
57
		sautLigneTpl = "<br />\n";
58
	}
813 jpm 59
 
453 jp_milcent 60
	protected String construireTxtTruck(String chaineAAnalyser) {
1369 cyprien 61
		return construireTxtTruck(chaineAAnalyser, true);
62
	}
63
 
64
	protected String construireTxtTruck(String chaineAAnalyser, boolean ucFirst) {
453 jp_milcent 65
		ArrayList<String> termes = new ArrayList<String>();
66
 
67
		if ((chaineAAnalyser != null) && (!chaineAAnalyser.trim().equals("")))	{
961 jpm 68
			String[] valeurs = chaineAAnalyser.split(aDonnee.SEPARATEUR_VALEURS);
453 jp_milcent 69
			int nbreValeurs = valeurs.length;
70
			if (nbreValeurs > 0)	{
71
				for (int i = 0; i < nbreValeurs; i++)	{
72
					String valeur = valeurs[i];
73
					String valeurFormatee = formaterValeurTruck(valeur);
74
					termes.add(valeurFormatee);
75
				}
76
			}
77
		}
78
 
1369 cyprien 79
		String chaineARetourner = formaterTableauDeTxt(termes, ucFirst);
453 jp_milcent 80
		return chaineARetourner;
81
	}
82
 
83
	private String formaterValeurTruck(String valeur) {
84
		String chaineARetourner = "";
85
 
86
		if (valeur.matches("^[^#]+##[^$]+$"))	{
961 jpm 87
			String[] cleValeur = valeur.split(aDonnee.SEPARATEUR_TYPE_VALEUR);
1044 gduche 88
			chaineARetourner = (UtilString.isEmpty(cleValeur[1]) || cleValeur[1].equals("null") ? aDonnee.VALEUR_NULL : cleValeur[1]) +" "+formaterParenthese(cleValeur[0]);
453 jp_milcent 89
		} else if (!valeur.equals(""))	{
90
			chaineARetourner = valeur;
91
		} else {
961 jpm 92
			GWT.log("Valeur truck posant problème :"+valeur, null);
453 jp_milcent 93
		}
94
 
95
		return chaineARetourner;
96
	}
97
 
98
	protected String formaterParenthese(String chaineAAfficher) {
99
		if (!chaineAAfficher.equals("")) {
100
			chaineAAfficher = "("+chaineAAfficher+")";
101
		}
102
		return chaineAAfficher;
103
	}
104
 
1369 cyprien 105
	protected String formaterTableauDeTxt(ArrayList<String> tableauDeTxt, boolean ucFirst) {
453 jp_milcent 106
		String chaineAAfficher = "";
107
		int tailleDuTableau = tableauDeTxt.size();
108
		if (tailleDuTableau > 0) {
109
			int indexAvtDernier = tailleDuTableau - 1;
110
			for (int i = 0; i < tailleDuTableau; i++)	{
111
				String mot = tableauDeTxt.get(i);
112
				if (i != indexAvtDernier) {
113
					chaineAAfficher += mot+", ";
114
				} else {
115
					chaineAAfficher += nettoyerPointFinal(mot)+".";
116
				}
117
			}
118
		}
1369 cyprien 119
		if (ucFirst) return UtilString.ucFirst(chaineAAfficher);
120
		else return chaineAAfficher;
453 jp_milcent 121
	}
122
 
123
	protected String nettoyerPointFinal(String mot) {
124
		mot = mot.replaceAll("[.]$", "");
125
		return mot;
126
	}
127
 
803 jpm 128
	protected String formaterContenu(String template, Params parametres) {
453 jp_milcent 129
		String cHtml = Format.substitute(template, parametres);
130
 
131
		Params cssParams = new Params();
1121 jpm 132
		cssParams.set("css_lien_ext", ComposantClass.LIEN_EXTERNE);
453 jp_milcent 133
		cssParams.set("css_corps", ComposantClass.DETAIL_CORPS_CONTENU);
134
		cssParams.set("css_label", ComposantClass.LABEL);
135
		cssParams.set("css_indentation", ComposantClass.INDENTATION);
136
		cssParams.set("css_fieldset", ComposantClass.FIELDSET);
137
		cssParams.set("css_clear", ComposantClass.CLEAR);
138
		cHtml = Format.substitute(cHtml, cssParams);
139
 
803 jpm 140
		return cHtml;
141
	}
142
 
143
	protected void afficherOnglet(String template, Params parametres, TabItem onglet) {
144
		String cHtml = formaterContenu(template, parametres);
145
 
453 jp_milcent 146
		HtmlContainer corpsConteneurDuHtml = new HtmlContainer(cHtml);
147
		onglet.removeAll();
148
		onglet.add(corpsConteneurDuHtml);
149
	}
150
 
151
	protected String formaterAutre(String chaineAAfficher) {
152
		if (!chaineAAfficher.equals("")) {
153
			chaineAAfficher = " ["+i18nC.autres()+" : "+chaineAAfficher+"]";
154
		}
155
		return chaineAAfficher;
156
	}
157
 
158
	protected String formaterOuiNon(String chaineAFormater) {
159
		String txtARetourner = "";
160
		if (chaineAFormater.equals("0")) {
161
			txtARetourner = i18nC.non();
162
		} else if (chaineAFormater.equals("1")) {
163
			txtARetourner = i18nC.oui();
164
		}
165
		return txtARetourner;
166
	}
1693 raphael 167
 
168
	protected String formaterOuiNon(Integer intAFormater) {
169
		if(intAFormater == null) return "";
170
		if(intAFormater.intValue() == 0) return i18nC.non();
171
		if(intAFormater.intValue() == 1) return i18nC.oui();
172
		return "";
173
	}
453 jp_milcent 174
 
175
	protected String formaterSautDeLigne(String chaineAFormater) {
176
		String txtARetourner = chaineAFormater.replaceAll("\n", sautLigneTpl);
177
		return txtARetourner;
178
	}
179
 
813 jpm 180
	protected void lancerChargementListesValeurs(String[] listesCodes) {
1322 gduche 181
		lancerChargementListesValeurs(listesCodes, null);
182
	}
183
	protected void lancerChargementListesValeurs(String[] listesCodes, Sequenceur sequenceur) {
813 jpm 184
		Configuration configuration = (Configuration) Registry.get(RegistreId.CONFIG);
185
		for (int i = 0; i < listesCodes.length ; i++) {
186
			String code = listesCodes[i];
187
			ontologiesEnAttenteDeReception.put(configuration.getListeId(code), code);
1322 gduche 188
			mediateur.obtenirListeValeurEtRafraichir(this, code, sequenceur);
813 jpm 189
		}
190
	}
191
 
816 jpm 192
	protected void receptionerListeValeurs(ValeurListe listeValeursReceptionnee) {
813 jpm 193
		mettreAJourOntologieEnAttenteDeReception(listeValeursReceptionnee);
194
		ajouterListeValeursAOntologie(listeValeursReceptionnee);
195
	}
196
 
197
	protected void mettreAJourOntologieEnAttenteDeReception(ValeurListe listeValeursReceptionnee) {
198
		ontologiesEnAttenteDeReception.remove(listeValeursReceptionnee.getId());
199
	}
200
 
201
	protected void ajouterListeValeursAOntologie(ValeurListe listeValeursReceptionnee) {
202
		Iterator<String> it = listeValeursReceptionnee.keySet().iterator();
453 jp_milcent 203
		while (it.hasNext()) {
204
			String cle = it.next();
813 jpm 205
			Valeur valeur = listeValeursReceptionnee.get(cle);
453 jp_milcent 206
			if (valeur != null) {
207
				ontologie.put(cle, valeur);
208
			}
209
		}
210
	}
524 gduche 211
 
936 jpm 212
	public String construireTxtListeOntologie(String chaineAAnalyser) {
967 jpm 213
		return construireTxtListeOntologie(chaineAAnalyser, true, true, false);
214
	}
215
 
216
	public String construireTxtListeOntologie(String chaineAAnalyser, boolean valeurEstOntologie, boolean typeEstOntologie, boolean donneeEstOntologie) {
524 gduche 217
		ArrayList<String> termes = new ArrayList<String>();
218
		ArrayList<String> autres = new ArrayList<String>();
1028 jpm 219
		chaineAAnalyser = chaineAAnalyser.trim();
220
		if (!UtilString.isEmpty(chaineAAnalyser)) {
961 jpm 221
			String[] valeurs = chaineAAnalyser.split(aDonnee.SEPARATEUR_VALEURS);
524 gduche 222
			int nbreValeurs = valeurs.length;
223
			if (nbreValeurs > 0)	{
224
				for (int i = 0; i < nbreValeurs; i++)	{
967 jpm 225
					String valeur = valeurs[i];
226
					// VALEUR SANS TYPE
227
					// La valeur sans type est une entrée de l'ontologie
228
					if (valeurEstOntologie && valeur.matches("^[0-9]+$"))	{
229
						if (valeur.equals("0")) {
230
							valeur = "";
231
						} else if (ontologie != null) {
1322 gduche 232
 
967 jpm 233
							Valeur valeurOntologie = ontologie.get(valeur);
234
							if (valeurOntologie != null) {
235
								valeur = valeurOntologie.getNom();
819 gduche 236
							}
524 gduche 237
						}
1322 gduche 238
 
967 jpm 239
					}
240
 
241
					// VALEUR AVEC TYPE
242
					// Type : AUTRE
243
					String valeurTypeAutre = aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR;
1329 cyprien 244
					if (valeur.matches("^"+valeurTypeAutre+".*$")) {
967 jpm 245
						String txtAutre = valeur.replaceFirst("^"+valeurTypeAutre, "");
246
						if (!txtAutre.equals("")) {
247
							autres.add(txtAutre);
248
						}
249
						valeur = "";
250
					}
251
					// Type correspondant à une entrée de l'ontologie
252
					if (typeEstOntologie) {
253
						String valeurTypeOntologie = "[0-9]+"+aDonnee.SEPARATEUR_TYPE_VALEUR;
254
						if (valeur.matches("^"+valeurTypeOntologie+".+$")) {
255
							String type = valeur.substring(0, valeur.indexOf(aDonnee.SEPARATEUR_TYPE_VALEUR));
256
							if (ontologie != null && ontologie.get(type) != null) {
257
								Valeur valeurOntologie = ontologie.get(type);
258
								valeur = valeur.replaceFirst("^"+type, valeurOntologie.getNom()+": ");
524 gduche 259
							}
260
						}
261
					}
967 jpm 262
					// Donnée correspondant à une entrée de l'ontologie
263
					if (donneeEstOntologie) {
264
						String donneeOntologie = aDonnee.SEPARATEUR_TYPE_VALEUR+"[0-9]+";
265
						if (valeur.matches("^.+"+donneeOntologie+"$")) {
266
							String donnee = valeur.substring(valeur.indexOf(aDonnee.SEPARATEUR_TYPE_VALEUR), valeur.length());
267
							donnee = donnee.replaceFirst("^"+aDonnee.SEPARATEUR_TYPE_VALEUR, "");
268
							if (ontologie != null && ontologie.get(donnee) != null) {
269
								Valeur valeurOntologie = ontologie.get(donnee);
270
								valeur = valeur.replaceFirst(donnee+"$", valeurOntologie.getNom());
271
							}
272
						}
273
					}
274
 
275
					// Nettoyage final
276
					valeur = valeur.replaceFirst(aDonnee.SEPARATEUR_TYPE_VALEUR, "");
277
 
278
					if (!UtilString.isEmpty(valeur)) {
279
						termes.add(valeur);
280
					}
524 gduche 281
				}
282
			}
283
		}
284
 
1369 cyprien 285
		String chaineTermes = formaterTableauDeTxt(termes, true);
286
		String chaineAutres = formaterTableauDeTxt(autres, true);
524 gduche 287
		String chaineARetourner = chaineTermes+formaterAutre(chaineAutres);
288
 
289
		return chaineARetourner;
290
	}
1693 raphael 291
}