WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/vues/collection/CollectionFormDescription.java


package org.tela_botanica.client.vues.collection;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampCaseACocher;
import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;
import org.tela_botanica.client.composants.ChampMultiValeursMultiTypes;
import org.tela_botanica.client.composants.ChampSliderPourcentage;
import org.tela_botanica.client.composants.InfoLogger;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.InterneValeur;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.collection.Collection;
import org.tela_botanica.client.modeles.collection.CollectionBotanique;
import org.tela_botanica.client.modeles.collection.UniteBase;
import org.tela_botanica.client.modeles.collection.UniteRangement;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.Pattern;
import org.tela_botanica.client.util.UtilNombre;
import org.tela_botanica.client.util.UtilString;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireOnglet;
 
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.FieldEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.MessageBoxEvent;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.LabelField;
import com.extjs.gxt.ui.client.widget.form.NumberField;
import com.extjs.gxt.ui.client.widget.form.TextArea;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.grid.AggregationRowConfig;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.HeaderGroupConfig;
import com.extjs.gxt.ui.client.widget.grid.SummaryType;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.i18n.client.NumberFormat;
 
public class CollectionFormDescription extends FormulaireOnglet implements Rafraichissable {
	
	public static final String ID = "description";
	private Collection collection = null;
	private CollectionBotanique collectionBotanique = null;
	private Collection collectionCollectee = null;
	private CollectionBotanique collectionBotaniqueCollectee = null;
	
	private static ListStore<InterneValeur> precisionStore = null;
	private ChampComboBoxListeValeurs typesCollectionBotaCombo = null;
	private NumberField nbreEchantillonChp = null;
	private EditorGrid<UniteRangement> uniteRangementGrille = null;
	private ChampComboBoxListeValeurs etatUniteRangementCombo = null;
	private EditorGrid<UniteBase> uniteBaseGrille = null;
	private ChampCaseACocher typePapierConservationChp = null;
	private ChampCaseACocher methodeConservationChp = null;
	private ChampSliderPourcentage specimenFixationPourcentChp = null;
	private ChampSliderPourcentage etiquetteFixationPourcentChp = null;
	private ChampCaseACocher specimentMethodeFixationChp = null;
	private ChampCaseACocher etiquetteMethodeFixationSurSupportChp = null;
	private ChampCaseACocher etiquetteMethodeFixationSurSpecimenChp = null;
	private ChampCaseACocher typeEcritureChp = null;
	private ChampComboBoxListeValeurs traitementCombo = null;
	private ChampCaseACocher poisonTraitementChp = null;
	private ChampCaseACocher insecteTraitementChp = null;
	private ChampComboBoxListeValeurs etatGeneralCombo = null;
	private ChampComboBoxListeValeurs determinationCombo = null;
	private ChampMultiValeursMultiTypes specimenDegradationChp = null;
	private ChampMultiValeursMultiTypes presentationDegradationChp = null;
	private Text labelPresentationDegradationChp = null;
		
	public CollectionFormDescription(Formulaire formulaireCourrant) {
		initialiserOnglet(formulaireCourrant);
		setId(ID);
		setText(Mediateur.i18nC.collectionDescription());
 
		FormLayout formulaireLayout = (FormLayout) this.getLayout();
		formulaireLayout.setLabelAlign(LabelAlign.LEFT);
		formulaireLayout.setLabelWidth(300);
		
		creerFieldsetPrecision();
		creerStorePrecision();
		creerUniteRangement();
		creerUniteBase();
		creerFieldsetConservation();
		creerFieldsetEtiquette();
		creerFieldsetTraitement();
		creerFieldsetEtat();
		
		layout();
	}
	
	private void creerFieldsetPrecision() {
		FieldSet precisionFieldSet = new FieldSet();
		precisionFieldSet.setHeading(i18nC.collectionTitrePrecision());
		precisionFieldSet.setCollapsible(true);
		precisionFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
		
		typesCollectionBotaCombo = new ChampComboBoxListeValeurs(i18nC.typeCollectionBotanique(), "typeCollectionBota");
		typesCollectionBotaCombo.setTabIndex(tabIndex++);
		precisionFieldSet.add(typesCollectionBotaCombo, new FormData(250, 0));
		
		nbreEchantillonChp = new NumberField(); 
		nbreEchantillonChp.setFieldLabel(i18nC.nbreEchantillon());
		nbreEchantillonChp.setToolTip(i18nC.nbreEchantillonInfo());
		nbreEchantillonChp.setFormat(NumberFormat.getFormat("#"));
		precisionFieldSet.add(nbreEchantillonChp);
		
		this.add(precisionFieldSet);
	}
	
	private static void creerStorePrecision() {
		if (precisionStore == null) {
			precisionStore = new ListStore<InterneValeur>();
			precisionStore.add(new InterneValeur(UniteRangement.COMPTE_APPROXIMATIF, Mediateur.i18nC.precisionApproximatif()));  
			precisionStore.add(new InterneValeur(UniteRangement.COMPTE_EXACT, Mediateur.i18nC.precisionExact()));
		}
	}
	
	private static String getPrecisionNom(String precisionAbr) {
		String precision = "";
		if (!precisionAbr.equals("NULL")) {
			creerStorePrecision();
			InterneValeur precisionValeur = precisionStore.findModel("abr", precisionAbr);
			if (precisionValeur != null && !precisionValeur.getNom().equals("NULL")) {
				precision = precisionValeur.getNom();
			}
		}
		return precision;
	}
	
	private static String getPrecisionAbr(String precisionNom) {
		String precision = "";
		if (!precisionNom.equals("NULL")) {
			creerStorePrecision();
			InterneValeur precisionValeur = precisionStore.findModel("nom", precisionNom);
			if (precisionValeur != null) {
				precision = precisionValeur.getAbr();
			}
		}
		return precision;
	}
	
	private ComboBox<InterneValeur> getChampPrecision() {
		ComboBox<InterneValeur> precisionCombo = new ComboBox<InterneValeur>();
		precisionCombo.setForceSelection(true);
		precisionCombo.setTriggerAction(TriggerAction.ALL);
		precisionCombo.setDisplayField("nom");
		precisionCombo.setStore(precisionStore);
		precisionCombo.setEditable(false);
		return precisionCombo;
	}
	
	private void creerUniteRangement() {
		ContentPanel panneauGrille = creerPanneauContenantGrille(i18nC.collectionUniteRangementTitre());
		
		uniteRangementGrille  = creerGrilleUniteRangement();
		mediateur.obtenirListeValeurEtRafraichir(this, "typeUniteRangement", null);
		panneauGrille.add(uniteRangementGrille);
		
		ToolBar barreOutils = creerBarreOutilsGrilleUniteRangement();
		panneauGrille.setTopComponent(barreOutils);
		
		add(panneauGrille);
	}
	
	private ContentPanel creerPanneauContenantGrille(String titre) {
		ContentPanel panneau = new ContentPanel();
		panneau.setHeading(titre);
		panneau.setIcon(Images.ICONES.table());
		panneau.setLayout(new FitLayout());
		panneau.setFrame(true);
		panneau.setScrollMode(Scroll.AUTO);
		panneau.setCollapsible(true);
		panneau.setStyleAttribute("margin", "5px 0");
		
		return panneau;
	}
	
	private EditorGrid<UniteRangement> creerGrilleUniteRangement() {
		ListStore<UniteRangement> storeGrille = new ListStore<UniteRangement>();
		
		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
		colonnes.add(new ColumnConfig("type", i18nC.collectionUniteType(), 150));
		
		NumberField champNombre = new NumberField();
		champNombre.setFormat(NumberFormat.getFormat("#"));
		
		ColumnConfig nombreColonne = new ColumnConfig("nombre", i18nC.collectionUniteNbre(), 50);
		nombreColonne.setEditor(new CellEditor(champNombre));
		nombreColonne.setNumberFormat(NumberFormat.getFormat("#"));
		colonnes.add(nombreColonne);
				
		CellEditor editeurPrecision = new CellEditor(getChampPrecision()) {  
			@Override  
			public Object preProcessValue(Object valeur) {  
				InterneValeur retour = null;
				if (valeur != null ) {
					if (precisionStore.findModel("nom", valeur.toString()) != null) {
						retour = precisionStore.findModel("nom", valeur.toString());
					} else if (precisionStore.findModel("abr", valeur.toString()) != null) {
						retour = precisionStore.findModel("abr", valeur.toString());
					}
				}
				return retour;
			}  
 
			@Override  
			public Object postProcessValue(Object valeur) {  
				String retour = null;
				if (valeur != null ) {
					if (valeur instanceof InterneValeur) {
						InterneValeur valeurInterne = (InterneValeur) valeur;
						retour = valeurInterne.getNom();
					}
				}
				return retour;  
			}
		};
		
		ColumnConfig precisionColonne = new ColumnConfig("precision", i18nC.collectionUnitePrecision(), 50);
		precisionColonne.setEditor(editeurPrecision);
		colonnes.add(precisionColonne);
		
		TextField<String> formatChp = new TextField<String>();
		ColumnConfig formatColonne =  new ColumnConfig("format", i18nC.collectionUniteFormat(), 100);
		formatColonne.setEditor(new CellEditor(formatChp));
		colonnes.add(formatColonne);
		
		GridSelectionModel<UniteRangement> modeleDeSelection = new GridSelectionModel<UniteRangement>();
		ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
		
		AggregationRowConfig<UniteBase> total = new AggregationRowConfig<UniteBase>();
		total.setHtml("type", i18nC.total());
		total.setSummaryType("nombre", SummaryType.SUM);
		total.setSummaryFormat("nombre", NumberFormat.getFormat("#"));
		modeleDeColonnes.addAggregationRow(total);
		
		EditorGrid<UniteRangement> grilleUniteRangement = new EditorGrid<UniteRangement>(storeGrille, modeleDeColonnes);
		grilleUniteRangement.setHeight(300);
		grilleUniteRangement.setBorders(true);
		grilleUniteRangement.setSelectionModel(modeleDeSelection);
		grilleUniteRangement.getView().setForceFit(true);
		grilleUniteRangement.getView().setAutoFill(true);
		grilleUniteRangement.setAutoExpandColumn("type");
		grilleUniteRangement.setStripeRows(true);
		grilleUniteRangement.setTrackMouseOver(true);
		
		return grilleUniteRangement;
	}
	
	private String collecterGrilleUniteRangement() {
		String truk = "";
		int nbreUnite = uniteRangementGrille.getStore().getCount();
		for (int i = 0; i < nbreUnite; i++) {
			UniteRangement unite = uniteRangementGrille.getStore().getAt(i);
			if (unite.getTypeAutre()) {
				truk += unite.getType();
			} else {
				truk += unite.getId();
			}
			truk += aDonnee.SEPARATEUR_TYPE_VALEUR;
			truk += UtilNombre.formaterEnEntier(unite.getNombre())+aDonnee.SEPARATEUR_DONNEES;
			truk += getPrecisionAbr(unite.getPrecision())+aDonnee.SEPARATEUR_DONNEES;
			truk += unite.getFormat();
			truk += (i == (nbreUnite - 1)) ? "" : aDonnee.SEPARATEUR_VALEURS;
		}
		return truk;
	}
	
	private void peuplerGrilleUniteRangement(String valeurTruk) {
		if (!UtilString.isEmpty(valeurTruk)) {
			HashMap<String,UniteRangement> unitesEnregistrees = parserValeurUniteRangement(valeurTruk);
			
			ArrayList<UniteRangement> listeUniteMaj = new ArrayList<UniteRangement>();
			int nbreUnite = uniteRangementGrille.getStore().getCount();
			for (int i = 0; i < nbreUnite; i++) {
				UniteRangement uniteDansGrille = uniteRangementGrille.getStore().getAt(i);
				UniteRangement uniteEnregistree = unitesEnregistrees.get(uniteDansGrille.getId());
				if (uniteEnregistree != null) {
					uniteEnregistree.setType(uniteDansGrille.getType());
					listeUniteMaj.add(uniteEnregistree);
				} else {
					listeUniteMaj.add(uniteDansGrille);
				}
			}
			
			Iterator<String> it = unitesEnregistrees.keySet().iterator();
			while (it.hasNext()) {
				String cle = it.next();
				if (cle.matches(aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR)) {
					UniteRangement uniteAutreEnregistree = unitesEnregistrees.get(cle);
					listeUniteMaj.add(uniteAutreEnregistree);
				}
			}
			
			uniteRangementGrille.getStore().removeAll();
			uniteRangementGrille.getStore().add(listeUniteMaj);
			layout();
		}
	}
	
	public static HashMap<String,UniteRangement> parserValeurUniteRangement(String valeurTruk) {
		HashMap<String,UniteRangement> unitesEnregistrees = new HashMap<String,UniteRangement>(); 
		if (!UtilString.isEmpty(valeurTruk)) {
			String[] unites = valeurTruk.split(Pattern.quote(aDonnee.SEPARATEUR_VALEURS));
			for (int i = 0; i < unites.length; i++) {
				String[] uniteTypeIdDonnees = unites[i].split(Pattern.quote(aDonnee.SEPARATEUR_TYPE_VALEUR));
				String uniteChaineDonnees = uniteTypeIdDonnees[1];
				String[] uniteDonnees = uniteChaineDonnees.split(Pattern.quote(aDonnee.SEPARATEUR_DONNEES));
				
				UniteRangement uniteRangement = new UniteRangement();
				if (uniteDonnees.length > 0) {
					uniteRangement.setNombre(UtilString.formaterEnEntier(uniteDonnees[0]));
				}
				if (uniteDonnees.length > 1) {
					uniteRangement.setPrecision(getPrecisionNom(uniteDonnees[1]));
				}
				if (uniteDonnees.length > 2) {
					uniteRangement.setFormat(uniteDonnees[2]);
				}
				
				if (uniteTypeIdDonnees[0].matches("[0-9]+")) {
					uniteRangement.setId(uniteTypeIdDonnees[0]);
					uniteRangement.setTypeAutre(false);
					unitesEnregistrees.put(uniteTypeIdDonnees[0], uniteRangement);
				} else {
					uniteRangement.setType(uniteTypeIdDonnees[0]);
					uniteRangement.setTypeAutre(true);
					String id = aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR+uniteTypeIdDonnees[0]+"-"+i;
					uniteRangement.setId(id);
					unitesEnregistrees.put(aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR, uniteRangement);
				}
			}
		}
		return unitesEnregistrees;
	}
	
	private ToolBar creerBarreOutilsGrilleUniteRangement() {
		ToolBar barreOutils = new ToolBar();  
		
		Button ajouterBouton = creerBoutonAjouterUniteRangement();
		barreOutils.add(ajouterBouton);
		
		barreOutils.add(new SeparatorToolItem());
		
		Button supprimerBouton = creerBoutonSupprimerUniteRangement();
		barreOutils.add(supprimerBouton);
		
		barreOutils.add(new SeparatorToolItem());
		barreOutils.add(new Text(i18nC.collectionUniteRangementEtatGeneralLabel()));
		etatUniteRangementCombo = new ChampComboBoxListeValeurs("", "etat");
		etatUniteRangementCombo.setEmptyText(i18nC.collectionUniteRangementEtatGeneral());
		etatUniteRangementCombo.setToolTip(i18nC.collectionUniteRangementEtatGeneralInfo());
		etatUniteRangementCombo.setTrie("id_valeur");
		etatUniteRangementCombo.setWidth(300);
		barreOutils.add(etatUniteRangementCombo);
		
		return barreOutils;
	}
	
	private Button creerBoutonAjouterUniteRangement() {
		Button bouton = new Button(i18nC.ajouter());
		bouton.setIcon(Images.ICONES.ajouter());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
			@Override
			public void componentSelected(ButtonEvent ce) {
				final MessageBox box = MessageBox.prompt(i18nC.collectionUniteType(), i18nC.collectionUniteRangementSaisirType());
					box.addCallback(new Listener<MessageBoxEvent>() {
					public void handleEvent(MessageBoxEvent be) {
						if (!UtilString.isEmpty(be.getValue()) && !be.getValue().matches("[0-9]+")) {
							final UniteRangement unite = new UniteRangement();
							unite.setType(be.getValue());
							unite.setTypeAutre(true);
							uniteRangementGrille.getStore().add(unite);
						} else {
							InfoLogger.display("Information", "Vous ne pouvez pas saisir de valeur vide ou numérique");
						}
					}
				});
			}
		});
		return bouton;
	}
	
	private Button creerBoutonSupprimerUniteRangement() {
		Button bouton = new Button(i18nC.supprimer());
		bouton.setIcon(Images.ICONES.supprimer());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
			@Override
			public void componentSelected(ButtonEvent ce) {
				UniteRangement uniteRangementSelectionnee = uniteRangementGrille.getSelectionModel().getSelectedItem();
				if (uniteRangementSelectionnee == null) {
					InfoLogger.display(i18nC.informationTitreGenerique(), Mediateur.i18nM.veuillezSelectionner(i18nC.selectionnerUniteRangement()));
				} else if (uniteRangementSelectionnee.getTypeAutre() == false) {
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerUniteRangementAjoute());
				} else {
					uniteRangementGrille.getStore().remove(uniteRangementSelectionnee);
				}
			}   
		});
		return bouton;
	}
	
	private void creerUniteBase() {
		ContentPanel panneauGrille = creerPanneauContenantGrille(i18nC.collectionUniteBaseTitre());
		
		uniteBaseGrille  = creerGrilleUniteBase();
		mediateur.obtenirListeValeurEtRafraichir(this, "typeUniteBase", null);
		panneauGrille.add(uniteBaseGrille);
		
		ToolBar barreOutils = creerBarreOutilsGrilleUniteBase();
		panneauGrille.setTopComponent(barreOutils);
		
		add(panneauGrille);		
	}
	
	private EditorGrid<UniteBase> creerGrilleUniteBase() {
		ListStore<UniteBase> storeGrille = new ListStore<UniteBase>();
		
		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
		colonnes.add(new ColumnConfig("type", i18nC.collectionUniteType(), 150));
		
		NumberField champNombre = new NumberField();
		champNombre.setFormat(NumberFormat.getFormat("#"));
		CellEditor editeurNombre = new CellEditor(champNombre);
		
		ColumnConfig nombreColonne = new ColumnConfig("nombre", i18nC.collectionUniteNbre(), 50);
		nombreColonne.setEditor(editeurNombre);
		nombreColonne.setNumberFormat(NumberFormat.getFormat("#"));
		colonnes.add(nombreColonne);
		
		CellEditor editeurPrecision = new CellEditor(getChampPrecision()) {  
			@Override  
			public Object preProcessValue(Object valeur) {  
				InterneValeur retour = null;
				if (valeur != null ) {
					if (precisionStore.findModel("nom", valeur.toString()) != null) {
						retour = precisionStore.findModel("nom", valeur.toString());
					} else if (precisionStore.findModel("abr", valeur.toString()) != null) {
						retour = precisionStore.findModel("abr", valeur.toString());
					}
				}
				return retour;
			}  
 
			@Override  
			public Object postProcessValue(Object valeur) {  
				String retour = null;
				if (valeur != null ) {
					if (valeur instanceof InterneValeur) {
						InterneValeur valeurInterne = (InterneValeur) valeur;
						retour = valeurInterne.getNom();
					}
				}
				return retour;
			}  
		};
		
		ColumnConfig precisionColonne = new ColumnConfig("precision", i18nC.collectionUnitePrecision(), 50);
		precisionColonne.setEditor(editeurPrecision);
		colonnes.add(precisionColonne);
		
		TextField<String> formatChp = new TextField<String>();
		ColumnConfig formatColonne =  new ColumnConfig("format", i18nC.collectionUniteFormat(), 100);
		formatColonne.setEditor(new CellEditor(formatChp));
		colonnes.add(formatColonne);
		
		ColumnConfig partNombreColonne = new ColumnConfig("nombre_part", i18nC.collectionUniteNbre(), 50);
		partNombreColonne.setEditor(editeurNombre);
		partNombreColonne.setNumberFormat(NumberFormat.getFormat("#"));
		colonnes.add(partNombreColonne);
		
		ColumnConfig partPrecisionColonne = new ColumnConfig("precision_part", i18nC.collectionUnitePrecision(), 50);
		partPrecisionColonne.setEditor(editeurPrecision);
		colonnes.add(partPrecisionColonne);
		
		ColumnConfig spNombreColonne = new ColumnConfig("nombre_sp", i18nC.collectionUniteNbre(), 50);
		spNombreColonne.setEditor(editeurNombre);
		spNombreColonne.setNumberFormat(NumberFormat.getFormat("#"));
		colonnes.add(spNombreColonne);
		
		ColumnConfig spPrecisionColonne = new ColumnConfig("precision_sp", i18nC.collectionUnitePrecision(), 50);
		spPrecisionColonne.setEditor(editeurPrecision);
		colonnes.add(spPrecisionColonne);
		
		GridSelectionModel<UniteBase> modeleDeSelection = new GridSelectionModel<UniteBase>();
		ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
		modeleDeColonnes.addHeaderGroup(0, 0, new HeaderGroupConfig(i18nC.collectionUniteBase(), 1, 4));
		modeleDeColonnes.addHeaderGroup(0, 4, new HeaderGroupConfig(i18nC.collectionUniteBasePart(), 1, 2));
		modeleDeColonnes.addHeaderGroup(0, 6, new HeaderGroupConfig(i18nC.collectionUniteBaseSp(), 1, 2));
		
		AggregationRowConfig<UniteBase> total = new AggregationRowConfig<UniteBase>();
		total.setHtml("type", "TOTAL");
		total.setSummaryType("nombre", SummaryType.SUM);
		total.setSummaryFormat("nombre", NumberFormat.getFormat("#"));
		total.setSummaryType("nombre_part", SummaryType.SUM);
		total.setSummaryFormat("nombre_part", NumberFormat.getFormat("#"));
		total.setSummaryType("nombre_sp", SummaryType.SUM);
		total.setSummaryFormat("nombre_sp", NumberFormat.getFormat("#"));
		modeleDeColonnes.addAggregationRow(total);
		
		EditorGrid<UniteBase> grilleUniteBase = new EditorGrid<UniteBase>(storeGrille, modeleDeColonnes);
		grilleUniteBase.setHeight(200);
		grilleUniteBase.setBorders(true);
		grilleUniteBase.setSelectionModel(modeleDeSelection);
		grilleUniteBase.getView().setForceFit(true);
		grilleUniteBase.getView().setAutoFill(true);
		grilleUniteBase.setAutoExpandColumn("type");
		grilleUniteBase.setStripeRows(true);
		grilleUniteBase.setTrackMouseOver(true);
		
		return grilleUniteBase;
	}
	
	private String collecterGrilleUniteBase() {
		String truk = "";
		int nbreUnite = uniteBaseGrille.getStore().getCount();
		for (int i = 0; i < nbreUnite; i++) {
			UniteBase unite = uniteBaseGrille.getStore().getAt(i);
			if (unite.getTypeAutre()) {
				truk += unite.getType();
			} else {
				truk += unite.getId();
			}
			truk += aDonnee.SEPARATEUR_TYPE_VALEUR;
			truk += UtilNombre.formaterEnEntier(unite.getNombre())+aDonnee.SEPARATEUR_DONNEES;
			truk += getPrecisionAbr(unite.getPrecision())+aDonnee.SEPARATEUR_DONNEES;
			truk += unite.getFormat()+aDonnee.SEPARATEUR_DONNEES;
			truk += UtilNombre.formaterEnEntier(unite.getNombrePart())+aDonnee.SEPARATEUR_DONNEES;
			truk += getPrecisionAbr(unite.getPrecisionPart())+aDonnee.SEPARATEUR_DONNEES;
			truk += UtilNombre.formaterEnEntier(unite.getNombreSp())+aDonnee.SEPARATEUR_DONNEES;
			truk += getPrecisionAbr(unite.getPrecisionSp());
			truk += (i == (nbreUnite - 1)) ? "" : aDonnee.SEPARATEUR_VALEURS;
		}
		return truk;
	}
	
	private void peuplerGrilleUniteBase(String valeurTruk) {
		if (!UtilString.isEmpty(valeurTruk)) {
			HashMap<String,UniteBase> unitesEnregistrees = parserValeurUniteBase(valeurTruk);
			
			ArrayList<UniteBase> listeUniteMaj = new ArrayList<UniteBase>();
			int nbreUnite = uniteBaseGrille.getStore().getCount();
			for (int i = 0; i < nbreUnite; i++) {
				UniteBase uniteDansGrille = uniteBaseGrille.getStore().getAt(i);
				UniteBase uniteEnregistree = unitesEnregistrees.get(uniteDansGrille.getId());
				if (uniteEnregistree != null) {
					uniteEnregistree.setType(uniteDansGrille.getType());
					listeUniteMaj.add(uniteEnregistree);
				} else {
					listeUniteMaj.add(uniteDansGrille);
				}
			}
			
			Iterator<String> it = unitesEnregistrees.keySet().iterator();
			while (it.hasNext()) {
				String cle = it.next();
				if (cle.matches(aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR)) {
					UniteBase uniteAutreEnregistree = unitesEnregistrees.get(cle);
					listeUniteMaj.add(uniteAutreEnregistree);
				}
			}
			
			uniteBaseGrille.getStore().removeAll();
			uniteBaseGrille.getStore().add(listeUniteMaj);
			layout();
		}
	}
	
	public static HashMap<String,UniteBase> parserValeurUniteBase(String valeurTruk) {
		HashMap<String,UniteBase> unitesEnregistrees = new HashMap<String,UniteBase>();
		if (!UtilString.isEmpty(valeurTruk)) {
			String[] unites = valeurTruk.split(Pattern.quote(aDonnee.SEPARATEUR_VALEURS));
			for (int i = 0; i < unites.length; i++) {
				String[] uniteTypeIdDonnees = unites[i].split(Pattern.quote(aDonnee.SEPARATEUR_TYPE_VALEUR));
				String uniteChaineDonnees = uniteTypeIdDonnees[1];
				String[] uniteDonnees = uniteChaineDonnees.split(Pattern.quote(aDonnee.SEPARATEUR_DONNEES));
				
				UniteBase uniteBase = new UniteBase();
				if (uniteDonnees.length > 0) {
					uniteBase.setNombre(UtilString.formaterEnEntier(uniteDonnees[0]));
				}
				if (uniteDonnees.length > 1) {
					uniteBase.setPrecision(getPrecisionNom(uniteDonnees[1]));
				}
				if (uniteDonnees.length > 2) {
					uniteBase.setFormat(uniteDonnees[2]);
				}
				if (uniteDonnees.length > 3) {
					uniteBase.setNombrePart(UtilString.formaterEnEntier(uniteDonnees[3]));
				}
				if (uniteDonnees.length > 4) {
					uniteBase.setPrecisionPart(getPrecisionNom(uniteDonnees[4]));
				}
				if (uniteDonnees.length > 5) {
					uniteBase.setNombreSp(UtilString.formaterEnEntier(uniteDonnees[5]));
				}
				if (uniteDonnees.length > 6) {
					uniteBase.setPrecisionSp(getPrecisionNom(uniteDonnees[6]));
				}
				
				if (uniteTypeIdDonnees[0].matches("[0-9]+")) {
					uniteBase.setId(uniteTypeIdDonnees[0]);
					uniteBase.setTypeAutre(false);
					unitesEnregistrees.put(uniteTypeIdDonnees[0], uniteBase);
				} else {
					uniteBase.setType(uniteTypeIdDonnees[0]);
					uniteBase.setTypeAutre(true);
					String id = aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR+uniteTypeIdDonnees[0]+"-"+i;
					uniteBase.setId(id);
					unitesEnregistrees.put(aDonnee.TYPE_AUTRE+aDonnee.SEPARATEUR_TYPE_VALEUR, uniteBase);					
				}
			}
		}
		return unitesEnregistrees;
	}
	
	private ToolBar creerBarreOutilsGrilleUniteBase() {
		ToolBar barreOutils = new ToolBar();  
		
		Button ajouterBouton = creerBoutonAjouterUniteBase();
		barreOutils.add(ajouterBouton);
		
		barreOutils.add(new SeparatorToolItem());
		
		Button supprimerBouton = creerBoutonSupprimerUniteBase();
		barreOutils.add(supprimerBouton);		
		
		return barreOutils;
	}
	
	private Button creerBoutonAjouterUniteBase() {
		Button bouton = new Button(i18nC.ajouter());
		bouton.setIcon(Images.ICONES.ajouter());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
			@Override
			public void componentSelected(ButtonEvent ce) {
				final MessageBox box = MessageBox.prompt(i18nC.collectionUniteType(), i18nC.collectionUniteBaseSaisirType());
					box.addCallback(new Listener<MessageBoxEvent>() {
					public void handleEvent(MessageBoxEvent be) {
						if (!UtilString.isEmpty(be.getValue()) && !be.getValue().matches("[0-9]+")) {
							final UniteBase unite = new UniteBase();
							unite.setType(be.getValue());
							unite.setTypeAutre(true);
							uniteBaseGrille.getStore().add(unite);
						} else {
							InfoLogger.display("Information", "Vous ne pouvez pas saisir de valeur vide ou numérique");
						}
					}
				});
			}
		});
		return bouton;
	}
	
	private Button creerBoutonSupprimerUniteBase() {
		Button bouton = new Button(i18nC.supprimer());
		bouton.setIcon(Images.ICONES.supprimer());
		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
			@Override
			public void componentSelected(ButtonEvent ce) {
				UniteBase uniteBaseSelectionnee = uniteBaseGrille.getSelectionModel().getSelectedItem();
				if (uniteBaseSelectionnee == null) {
					InfoLogger.display(i18nC.informationTitreGenerique(), Mediateur.i18nM.veuillezSelectionner(i18nC.selectionnerUniteBase()));
				} else if (uniteBaseSelectionnee.getTypeAutre() == false) {
					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerUniteBaseAjoute());
				} else {
					uniteBaseGrille.getStore().remove(uniteBaseSelectionnee);
				}
			}   
		});
		return bouton;
	}
	
	private void creerFieldsetConservation() {
		FieldSet conservationFieldSet = new FieldSet();
		conservationFieldSet.setHeading(i18nC.collectionTitreConservation());
		conservationFieldSet.setCollapsible(true);
		conservationFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
		
		typePapierConservationChp = new ChampCaseACocher(i18nC.typePapierConservation(), "typePapier", true);
		conservationFieldSet.add(typePapierConservationChp);
		
		methodeConservationChp = new ChampCaseACocher(i18nC.methodeConservation(), "methodeRangement", true);
		conservationFieldSet.add(methodeConservationChp);
		
		this.add(conservationFieldSet);
	}
	
	private void creerFieldsetEtiquette() {
		FieldSet etiquetteFieldSet = new FieldSet();
		etiquetteFieldSet.setHeading(i18nC.collectionTitreEtiquette());
		etiquetteFieldSet.setCollapsible(true);
		etiquetteFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
		
		Text fixationPoucentLabel = new Text(i18nC.fixationPourcent());
		etiquetteFieldSet.add(fixationPoucentLabel);
		
		specimenFixationPourcentChp = new ChampSliderPourcentage(i18nC.specimenFixationPourcent());
		etiquetteFieldSet.add(specimenFixationPourcentChp, new FormData(200, 0));
		
		etiquetteFixationPourcentChp = new ChampSliderPourcentage(i18nC.etiquetteFixationPourcent());
		etiquetteFieldSet.add(etiquetteFixationPourcentChp, new FormData(200, 0));
		
		specimentMethodeFixationChp = new ChampCaseACocher(i18nC.specimenMethodeFixation(), "methodeFixation", true);
		etiquetteFieldSet.add(specimentMethodeFixationChp);
		
		etiquetteMethodeFixationSurSupportChp = new ChampCaseACocher(i18nC.etiquetteMethodeFixationSurSupport(), "methodeFixation", true);
		etiquetteFieldSet.add(etiquetteMethodeFixationSurSupportChp);
		
		etiquetteMethodeFixationSurSpecimenChp = new ChampCaseACocher(i18nC.etiquetteMethodeFixationSurSpecimen(), "methodeFixationSurSpecimen", true);
		etiquetteFieldSet.add(etiquetteMethodeFixationSurSpecimenChp);
		
		typeEcritureChp = new ChampCaseACocher(i18nC.typeEcriture(), "typeEcriture", false);
		etiquetteFieldSet.add(typeEcritureChp);
		
		this.add(etiquetteFieldSet);
	}
	
	private void creerFieldsetTraitement() {
		FieldSet traitementFieldSet = new FieldSet();
		traitementFieldSet.setHeading(i18nC.collectionTitreTraitement());
		traitementFieldSet.setCollapsible(true);
		traitementFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
		
		traitementCombo  = new ChampComboBoxListeValeurs(i18nC.collectionTraitement(), "onpi");
		traitementCombo.setTrie("id_valeur");
		traitementFieldSet.add(traitementCombo, new FormData(300, 0));
		
		poisonTraitementChp = new ChampCaseACocher(i18nC.collectionTraitementPoison(), "poisonTraitement", true);
		traitementFieldSet.add(poisonTraitementChp);
		
		insecteTraitementChp = new ChampCaseACocher(i18nC.collectionTraitementInsecte(), "insecteTraitement", true);
		traitementFieldSet.add(insecteTraitementChp);
 
		this.add(traitementFieldSet);
	}
	
	private void creerFieldsetEtat() {
		FieldSet etatFieldSet = new FieldSet();
		etatFieldSet.setHeading(i18nC.collectionTitreEtatEtDegradation());
		etatFieldSet.setCollapsible(true);
		etatFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
		
		etatGeneralCombo = new ChampComboBoxListeValeurs(i18nC.collectionEtatGeneral(), "etat");
		etatGeneralCombo.setToolTip(i18nC.collectionEtatGeneralInfo());
		etatGeneralCombo.setTrie("id_valeur");
		etatFieldSet.add(etatGeneralCombo, new FormData(300, 0));
		
		specimenDegradationChp = new ChampMultiValeursMultiTypes(i18nC.degradationSpecimen(), 150, true);
		specimenDegradationChp.initialiserType("specimenDegradation");
		specimenDegradationChp.initialiserCombobox("niveauImportance");
		etatFieldSet.add(specimenDegradationChp);
		
		labelPresentationDegradationChp = new Text();
		labelPresentationDegradationChp.setWidth("95%");
		labelPresentationDegradationChp.setVisible(false);
		
		presentationDegradationChp = new ChampMultiValeursMultiTypes(i18nC.degradationPresentation(), 150, 200, true);
		presentationDegradationChp.initialiserType("supportDegradation");
		presentationDegradationChp.initialiserCombobox("niveauImportance");
		
		presentationDegradationChp.getTypes().addListener(Events.Select,
			new Listener<FieldEvent>() {
				public void handleEvent(FieldEvent be) {
					if (((Valeur)(be.getField().getValue())).get("id_valeur").equals("2310")) {
						labelPresentationDegradationChp.setText(i18nC.degradationPresentationLabel());
						labelPresentationDegradationChp.setVisible(true);
					}
					else {
						labelPresentationDegradationChp.setText("");
						labelPresentationDegradationChp.setVisible(false);						
					}
				}		
			});
		etatFieldSet.add(presentationDegradationChp);
		etatFieldSet.add(labelPresentationDegradationChp);
		
		determinationCombo = new ChampComboBoxListeValeurs(i18nC.collectionDetermination(), "niveauDetermination");
		determinationCombo.setTrie("id_valeur");
		etatFieldSet.add(determinationCombo, new FormData(450, 0));
		
		this.add(etatFieldSet);
	}
	
	public void peupler() {
		initialiserCollection();
		if (collectionBotanique != null) {
			typesCollectionBotaCombo.peupler(collectionBotanique.getType());
			if (!UtilString.isEmpty(collectionBotanique.getNbreEchantillon())) {
				nbreEchantillonChp.setValue(Integer.parseInt(collectionBotanique.getNbreEchantillon()));
			}
			
			peuplerGrilleUniteRangement(collectionBotanique.getUniteRangement());
			etatUniteRangementCombo.peupler(collectionBotanique.getUniteRangementEtat());
			
			peuplerGrilleUniteBase(collectionBotanique.getUniteBase());
			
			typePapierConservationChp.peupler(collectionBotanique.getConservationPapierType());
			methodeConservationChp.peupler(collectionBotanique.getConservationMethode());
			
			specimenFixationPourcentChp.peupler(collectionBotanique.getSpecimenFixationPourcent());
			etiquetteFixationPourcentChp.peupler(collectionBotanique.getEtiquetteFixationPourcent());
			specimentMethodeFixationChp.peupler(collectionBotanique.getSpecimenFixationMethode());
			etiquetteMethodeFixationSurSupportChp.peupler(collectionBotanique.getEtiquetteFixationSupport());
			etiquetteMethodeFixationSurSpecimenChp.peupler(collectionBotanique.getEtiquetteFixationSpecimen());
			typeEcritureChp.peupler(collectionBotanique.getEtiquetteEcriture());
			
			traitementCombo.peupler(collectionBotanique.getTraitement());
			poisonTraitementChp.peupler(collectionBotanique.getTraitementPoison());
			insecteTraitementChp.peupler(collectionBotanique.getTraitementInsecte());
			
			etatGeneralCombo.peupler(collectionBotanique.getEtatGeneral());
			specimenDegradationChp.peupler(collectionBotanique.getDegradationSpecimen());
			presentationDegradationChp.peupler(collectionBotanique.getDegradationPresentation());
			determinationCombo.peupler(collectionBotanique.getDetermination());
		}		
	}
	
	public void collecter() {
		initialiserCollection();
		if (etreAccede()) {
			collectionBotaniqueCollectee.setType(typesCollectionBotaCombo.getValeur());
			if (nbreEchantillonChp.getValue() != null) {
				collectionBotaniqueCollectee.setNbreEchantillon(Integer.toString(nbreEchantillonChp.getValue().intValue()));
			}
			
			collectionBotaniqueCollectee.setUniteRangement(collecterGrilleUniteRangement());
			collectionBotaniqueCollectee.setUniteRangementEtat(etatUniteRangementCombo.getValeur());
			
			collectionBotaniqueCollectee.setUniteBase(collecterGrilleUniteBase());
			
			collectionBotaniqueCollectee.setConservationPapierType(typePapierConservationChp.getValeur());
			collectionBotaniqueCollectee.setConservationMethode(methodeConservationChp.getValeur());
			
			collectionBotaniqueCollectee.setSpecimenFixationPourcent(specimenFixationPourcentChp.getValeur());
			collectionBotaniqueCollectee.setEtiquetteFixationPourcent(etiquetteFixationPourcentChp.getValeur());
			collectionBotaniqueCollectee.setSpecimenFixationMethode(specimentMethodeFixationChp.getValeur());
			collectionBotaniqueCollectee.setEtiquetteFixationSupport(etiquetteMethodeFixationSurSupportChp.getValeur());
			collectionBotaniqueCollectee.setEtiquetteFixationSpecimen(etiquetteMethodeFixationSurSpecimenChp.getValeur());
			collectionBotaniqueCollectee.setEtiquetteEcriture(typeEcritureChp.getValeur());
			
			collectionBotaniqueCollectee.setTraitement(traitementCombo.getValeur());
			collectionBotaniqueCollectee.setTraitementPoison(poisonTraitementChp.getValeur());
			collectionBotaniqueCollectee.setTraitementInsecte(insecteTraitementChp.getValeur());
			
			collectionBotaniqueCollectee.setEtatGeneral(etatGeneralCombo.getValeur());
			collectionBotaniqueCollectee.setDegradationSpecimen(specimenDegradationChp.getValeurs());
			collectionBotaniqueCollectee.setDegradationPresentation(presentationDegradationChp.getValeurs());
			collectionBotaniqueCollectee.setDetermination(determinationCombo.getValeur());
		}
	}
 
	private void initialiserCollection() {
		collection = ((CollectionForm) formulaire).collection;
		if (collection != null) {
			collectionBotanique = collection.getBotanique();
		}
		
		collectionCollectee = ((CollectionForm) formulaire).collectionCollectee;
		if (collectionCollectee != null) {
			collectionBotaniqueCollectee = collectionCollectee.getBotanique();
		}
	}
	
	public void rafraichir(Object nouvellesDonnees) {
		if (nouvellesDonnees instanceof ValeurListe) {
			ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
			rafraichirValeurListe(listeValeurs);
		} else {
			Debug.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()));
		}
	}
	
	private void rafraichirValeurListe(ValeurListe listeValeurs) {
		if (listeValeurs.getId().equals(config.getListeId("typeUniteRangement"))) {
			Iterator<String> it = listeValeurs.keySet().iterator();
			while (it.hasNext()) {
				Valeur valeur = listeValeurs.get(it.next());
				UniteRangement unite = new UniteRangement();
				unite.setId(valeur.getId());
				unite.setType(valeur.getNom());
				unite.setTypeAutre(false);
				uniteRangementGrille.getStore().add(unite);
			}
		} else if (listeValeurs.getId().equals(config.getListeId("typeUniteBase"))) {
			Iterator<String> it = listeValeurs.keySet().iterator();
			while (it.hasNext()) {
				Valeur valeur = listeValeurs.get(it.next());
				UniteBase unite = new UniteBase();
				unite.setId(valeur.getId());
				unite.setType(valeur.getNom());
				unite.setTypeAutre(false);
				uniteBaseGrille.getStore().add(unite);
			}
		} else {
			Debug.log("Gestion de la liste "+listeValeurs.getId()+" non implémenté!");
		}
	}
}
Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/vues/collection/CollectionFormDescription.java @ 1373 – Rev 1262 → 1322

Rev 1262		Rev 1322
1	`package org.tela_botanica.client.vues.collection;`	1	`package org.tela_botanica.client.vues.collection;`
2		2
3	`import java.util.ArrayList;`	3	`import java.util.ArrayList;`
4	`import java.util.HashMap;`	4	`import java.util.HashMap;`
5	`import java.util.Iterator;`	5	`import java.util.Iterator;`
6	`import java.util.List;`	6	`import java.util.List;`
7		7
8	`import org.tela_botanica.client.Mediateur;`	8	`import org.tela_botanica.client.Mediateur;`
9	`import org.tela_botanica.client.composants.ChampCaseACocher;`	9	`import org.tela_botanica.client.composants.ChampCaseACocher;`
10	`import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;`	10	`import org.tela_botanica.client.composants.ChampComboBoxListeValeurs;`
11	`import org.tela_botanica.client.composants.ChampMultiValeursMultiTypes;`	11	`import org.tela_botanica.client.composants.ChampMultiValeursMultiTypes;`
12	`import org.tela_botanica.client.composants.ChampSliderPourcentage;`	12	`import org.tela_botanica.client.composants.ChampSliderPourcentage;`
13	`import org.tela_botanica.client.composants.InfoLogger;`	13	`import org.tela_botanica.client.composants.InfoLogger;`
14	`import org.tela_botanica.client.images.Images;`	14	`import org.tela_botanica.client.images.Images;`
15	`import org.tela_botanica.client.interfaces.Rafraichissable;`	15	`import org.tela_botanica.client.interfaces.Rafraichissable;`
16	`import org.tela_botanica.client.modeles.InterneValeur;`	16	`import org.tela_botanica.client.modeles.InterneValeur;`
17	`import org.tela_botanica.client.modeles.Valeur;`	17	`import org.tela_botanica.client.modeles.Valeur;`
18	`import org.tela_botanica.client.modeles.ValeurListe;`	18	`import org.tela_botanica.client.modeles.ValeurListe;`
19	`import org.tela_botanica.client.modeles.aDonnee;`	19	`import org.tela_botanica.client.modeles.aDonnee;`
20	`import org.tela_botanica.client.modeles.collection.Collection;`	20	`import org.tela_botanica.client.modeles.collection.Collection;`
21	`import org.tela_botanica.client.modeles.collection.CollectionBotanique;`	21	`import org.tela_botanica.client.modeles.collection.CollectionBotanique;`
22	`import org.tela_botanica.client.modeles.collection.UniteBase;`	22	`import org.tela_botanica.client.modeles.collection.UniteBase;`
23	`import org.tela_botanica.client.modeles.collection.UniteRangement;`	23	`import org.tela_botanica.client.modeles.collection.UniteRangement;`
24	`import org.tela_botanica.client.util.Debug;`	24	`import org.tela_botanica.client.util.Debug;`
25	`import org.tela_botanica.client.util.Pattern;`	25	`import org.tela_botanica.client.util.Pattern;`
26	`import org.tela_botanica.client.util.UtilNombre;`	26	`import org.tela_botanica.client.util.UtilNombre;`
27	`import org.tela_botanica.client.util.UtilString;`	27	`import org.tela_botanica.client.util.UtilString;`
28	`import org.tela_botanica.client.vues.Formulaire;`	28	`import org.tela_botanica.client.vues.Formulaire;`
29	`import org.tela_botanica.client.vues.FormulaireOnglet;`	29	`import org.tela_botanica.client.vues.FormulaireOnglet;`
30		30
31	`import com.extjs.gxt.ui.client.Style.Scroll;`	31	`import com.extjs.gxt.ui.client.Style.Scroll;`
32	`import com.extjs.gxt.ui.client.event.BaseEvent;`	32	`import com.extjs.gxt.ui.client.event.BaseEvent;`
33	`import com.extjs.gxt.ui.client.event.ButtonEvent;`	33	`import com.extjs.gxt.ui.client.event.ButtonEvent;`
34	`import com.extjs.gxt.ui.client.event.ComponentEvent;`	34	`import com.extjs.gxt.ui.client.event.ComponentEvent;`
35	`import com.extjs.gxt.ui.client.event.Events;`	35	`import com.extjs.gxt.ui.client.event.Events;`
36	`import com.extjs.gxt.ui.client.event.FieldEvent;`	36	`import com.extjs.gxt.ui.client.event.FieldEvent;`
37	`import com.extjs.gxt.ui.client.event.Listener;`	37	`import com.extjs.gxt.ui.client.event.Listener;`
38	`import com.extjs.gxt.ui.client.event.MessageBoxEvent;`	38	`import com.extjs.gxt.ui.client.event.MessageBoxEvent;`
39	`import com.extjs.gxt.ui.client.event.SelectionListener;`	39	`import com.extjs.gxt.ui.client.event.SelectionListener;`
40	`import com.extjs.gxt.ui.client.store.ListStore;`	40	`import com.extjs.gxt.ui.client.store.ListStore;`