Subversion Repositories eFlore/Applications.coel

Rev

Rev 1924 | 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.ChampNombre;
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.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.modeles.OntologiesLocales;
import org.tela_botanica.client.modeles.SimpleModelData;
import org.tela_botanica.client.util.Debug;
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.event.Events;
import com.extjs.gxt.ui.client.event.FieldEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.widget.Label;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
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.FormPanel.LabelAlign;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.google.gwt.i18n.client.NumberFormat;
import com.google.gwt.user.client.ui.HorizontalPanel;


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 ComboBox<SimpleModelData> 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 ComboBox<SimpleModelData> etatGeneralCombo = null;
        private ChampComboBoxListeValeurs determinationCombo = null;
        private ChampMultiValeursMultiTypes specimenDegradationChp = null;
        private ChampMultiValeursMultiTypes presentationDegradationChp = null;
        private Text labelPresentationDegradationChp = null;
        private ChampNombre planchesHerbier = null;
        private ChampNombre nbEspeces = null;
        private ChampNombre nbCartonsHerbier = null;
        private TextField<String> cartonsHerbierFormat = null;
        private ChampNombre nbLiasses = null;
        private TextField<String> liassesFormat = null;
        private TextArea autresUnitesRangement = 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);
                
                creerFieldsetTypesUniteEtat();
                
                creerFieldsetConservation(); // Papier
                
                creerFieldsetEtiquette(); // RAS
                creerFieldsetTraitement(); // RAS
                
                creerFieldsetPrecision(); // A supprimer ou déplacer plus tard
                creerStorePrecision();
                
                layout();
        }
        
        private void creerFieldsetPrecision() {
                FieldSet precisionFieldSet = new FieldSet();
                precisionFieldSet.setHeadingHtml(i18nC.collectionTitrePrecision());
                precisionFieldSet.setCollapsible(true);
                precisionFieldSet.collapse();
                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 void creerFieldsetConservation() {
                FieldSet conservationFieldSet = new FieldSet();
                conservationFieldSet.setHeadingHtml(i18nC.collectionTitreConservation());
                conservationFieldSet.setCollapsible(true);
                conservationFieldSet.collapse();
                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.setHeadingHtml(i18nC.collectionTitreEtiquette());
                etiquetteFieldSet.setCollapsible(true);
                etiquetteFieldSet.collapse();
                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.setHeadingHtml(i18nC.collectionTitreTraitement());
                traitementFieldSet.setCollapsible(true);
                traitementFieldSet.collapse();
                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 creerFieldsetTypesUniteEtat() {
                FieldSet etatTypesUniteFieldSet = new FieldSet();
                // Etat général et nombre d'échantillons (à changer dans l'i18n
                etatTypesUniteFieldSet.setHeadingHtml(i18nC.collectionEtatGeneralEtNombreEchantillons());
                etatTypesUniteFieldSet.setCollapsible(true);
                etatTypesUniteFieldSet.collapse();
                etatTypesUniteFieldSet.setLayout(Formulaire.creerFormLayout(largeurLabelDefaut, alignementLabelDefaut));
                
                etatUniteRangementCombo = creerSimpleComboBonMauvaisEtat(i18nC.collectionUniteRangementEtatGeneral());
                etatTypesUniteFieldSet.add(etatUniteRangementCombo, new FormData(300, 0));
                
                // Liasses et cartons d'herbier
                Label labelcartonsHerbiersFormat = new Label(i18nC.collectionCartonsHerbiers());
                labelcartonsHerbiersFormat.setStyleName("labelChampNombreFormat");
                
                nbCartonsHerbier = new ChampNombre();
                nbCartonsHerbier.setStyleName("champNombreFormat");
                nbCartonsHerbier.setWidth(55);
                nbCartonsHerbier.setEmptyText(i18nC.collectionUniteNbre());
                
                cartonsHerbierFormat = new TextField<String>();
                cartonsHerbierFormat.setStyleName("champNombreFormat");
                cartonsHerbierFormat.setEmptyText(i18nC.collectionUniteFormat());
                
                HorizontalPanel conteneurCartonsHerbiers = new HorizontalPanel();
                conteneurCartonsHerbiers.setBorderWidth(0);
                
                conteneurCartonsHerbiers.add(labelcartonsHerbiersFormat);
                conteneurCartonsHerbiers.add(nbCartonsHerbier);
                conteneurCartonsHerbiers.add(cartonsHerbierFormat);
                
                etatTypesUniteFieldSet.add(conteneurCartonsHerbiers);
                
                Label labelLiasses = new Label(i18nC.collectionLiasses());
                labelLiasses.setStyleName("labelChampNombreFormat");
                
                nbLiasses = new ChampNombre();
                nbLiasses.setStyleName("champNombreFormat");
                nbLiasses.setWidth(55);
                nbLiasses.setEmptyText(i18nC.collectionUniteNbre());
                
                liassesFormat = new TextField<String>();
                liassesFormat.setStyleName("champNombreFormat");
                liassesFormat.setEmptyText(i18nC.collectionUniteFormat());
                
                HorizontalPanel conteneurLiasses = new HorizontalPanel();
                conteneurLiasses.setBorderWidth(0);
                
                conteneurLiasses.add(labelLiasses);
                conteneurLiasses.add(nbLiasses);
                conteneurLiasses.add(liassesFormat);
                
                etatTypesUniteFieldSet.add(conteneurLiasses);
                
                autresUnitesRangement = new TextArea();
                autresUnitesRangement.setStyleName("textAreaAutreUniteRangement");
                autresUnitesRangement.setHeight(90);
                autresUnitesRangement.setFieldLabel(i18nC.collectionAutreUnitesRangement());
                
                etatTypesUniteFieldSet.add(autresUnitesRangement);
                
                planchesHerbier = new ChampNombre();
                planchesHerbier.setFieldLabel(i18nC.collectionNbPlanchesHerbier());
                
                nbEspeces = new ChampNombre();
                nbEspeces.setFieldLabel(i18nC.collectionNbEspeces());
                
                etatTypesUniteFieldSet.add(planchesHerbier);
                etatTypesUniteFieldSet.add(nbEspeces);
                
                add(etatTypesUniteFieldSet);
                

                etatGeneralCombo = creerSimpleComboBonMauvaisEtat(i18nC.collectionEtatGeneral());
                etatTypesUniteFieldSet.add(etatGeneralCombo, new FormData(300, 0));
                
                specimenDegradationChp = new ChampMultiValeursMultiTypes(i18nC.degradationSpecimen(), 150, true);
                specimenDegradationChp.initialiserType("specimenDegradation");
                specimenDegradationChp.initialiserCombobox("niveauImportance");
                etatTypesUniteFieldSet.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);                                              
                                        }
                                }               
                        });
                etatTypesUniteFieldSet.add(presentationDegradationChp);
                etatTypesUniteFieldSet.add(labelPresentationDegradationChp);
                
                determinationCombo = new ChampComboBoxListeValeurs(i18nC.collectionDetermination(), "niveauDetermination");
                determinationCombo.setTrie("id_valeur");
                etatTypesUniteFieldSet.add(determinationCombo, new FormData(450, 0));
                
                this.add(etatTypesUniteFieldSet);
        }
        
        public void peupler() {
                initialiserCollection();
                if (collectionBotanique != null) {
                        typesCollectionBotaCombo.peupler(collectionBotanique.getType());
                        if (!UtilString.isEmpty(collectionBotanique.getNbreEchantillon())) {
                                nbreEchantillonChp.setValue(Integer.parseInt(collectionBotanique.getNbreEchantillon()));
                        }
                        
                        if(!collectionBotanique.getNbCartonsHerbiers().isEmpty()) {
                                nbCartonsHerbier.setValue((Integer.parseInt(collectionBotanique.getNbCartonsHerbiers())));
                        }
                        cartonsHerbierFormat.setValue(collectionBotanique.getFormatCartonsHerbiers());
                        
                        if(!collectionBotanique.getNbLiasses().isEmpty()) {
                                nbLiasses.setValue((Integer.parseInt(collectionBotanique.getNbLiasses())));
                        }
                        liassesFormat.setValue(collectionBotanique.getFormatLiasses());
                        
                        autresUnitesRangement.setValue(collectionBotanique.getAutresUnitesRangement());

                        remplirSimpleCombo(etatUniteRangementCombo, collectionBotanique.getUniteRangementEtat());
                        
                        
                        if(!collectionBotanique.getNbPlanchesHerbiers().isEmpty()) {
                                planchesHerbier.setValue((Integer.parseInt(collectionBotanique.getNbPlanchesHerbiers())));
                        }
                        
                        if(!collectionBotanique.getNbEspeces().isEmpty()) {
                                nbEspeces.setValue((Integer.parseInt(collectionBotanique.getNbEspeces())));
                        }
                        
                        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());
                        
                        remplirSimpleCombo(etatGeneralCombo, 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.setNbCartonsHerbiers(nbCartonsHerbier.getValue()+"");
                        collectionBotaniqueCollectee.setFormatCartonsHerbiers(cartonsHerbierFormat.getValue());
                        collectionBotaniqueCollectee.setNbLiasses(nbLiasses.getValue()+"");
                        collectionBotaniqueCollectee.setFormatLiasses(liassesFormat.getValue());
                        collectionBotaniqueCollectee.setAutresUnitesRangement(autresUnitesRangement.getValue());
                        
                        collectionBotaniqueCollectee.setUniteRangementEtat(etatUniteRangementCombo.getValue().getCle());
                        
                        collectionBotaniqueCollectee.setNbPlanchesHerbiers(planchesHerbier.getValue()+"");
                        collectionBotaniqueCollectee.setNbEspeces(nbEspeces.getValue()+"");
                        
                        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.getValue().getCle());
                        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 remplirSimpleCombo(ComboBox<SimpleModelData> simpleCombo, String valeur) {
                SimpleModelData selectionne = simpleCombo.getStore().findModel("cle", valeur);
                simpleCombo.setValue(selectionne);
        }
        
        public ComboBox<SimpleModelData> creerSimpleComboBonMauvaisEtat(String label) {
                ListStore<SimpleModelData> listeBonMauvaisEtat = OntologiesLocales.convertirVersListeStore(OntologiesLocales.getListeBonMauvaisEtat());
                ComboBox<SimpleModelData> combo = new ComboBox<SimpleModelData>();
                combo.setForceSelection(true);
                combo.setTriggerAction(TriggerAction.ALL);
                combo.setFieldLabel(label);
                combo.setDisplayField("valeur");
                combo.setValueField("cle");
                listeBonMauvaisEtat.sort("ordre", SortDir.ASC);
                combo.setStore(listeBonMauvaisEtat);
                return combo;
        }
        
        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é!");
                }
        }
}