Subversion Repositories eFlore/Applications.coel

Rev

Rev 1369 | Rev 1437 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

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;
                        
                        if (truk.matches("^"+aDonnee.SEPARATEUR_DONNEES)) {
                                truk = truk.replaceFirst("^"+aDonnee.SEPARATEUR_DONNEES, "");
                        }
                        
                        if (truk.matches("^"+aDonnee.SEPARATEUR_TYPE_VALEUR)) {
                                truk = truk.replaceFirst("^"+aDonnee.SEPARATEUR_TYPE_VALEUR, "");
                        }
                }
                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é!");
                }
        }
}