Subversion Repositories eFlore/Applications.coel

Rev

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

package org.tela_botanica.client.vues;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.tela_botanica.client.ComposantId;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.Modele;
import org.tela_botanica.client.RegistreId;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.InterneValeur;
import org.tela_botanica.client.modeles.InterneValeurListe;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureAPersonne;
import org.tela_botanica.client.modeles.StructureAPersonneListe;
import org.tela_botanica.client.modeles.StructureConservation;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.StructureValorisation;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.ValeurListe;

import com.extjs.gxt.ui.client.Events;
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.HorizontalAlignment;
import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.event.ToolBarEvent;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.widget.Component;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.TabItem;
import com.extjs.gxt.ui.client.widget.TabPanel;
import com.extjs.gxt.ui.client.widget.WidgetComponent;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.CheckBox;
import com.extjs.gxt.ui.client.widget.form.CheckBoxGroup;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
import com.extjs.gxt.ui.client.widget.form.DateField;
import com.extjs.gxt.ui.client.widget.form.Field;
import com.extjs.gxt.ui.client.widget.form.FieldSet;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.HiddenField;
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.Radio;
import com.extjs.gxt.ui.client.widget.form.RadioGroup;
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.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.CheckBoxSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.CheckColumnConfig;
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.layout.ColumnData;
import com.extjs.gxt.ui.client.widget.layout.ColumnLayout;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FlowLayout;
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.tips.ToolTipConfig;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.TextToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.i18n.client.DateTimeFormat;
import com.google.gwt.i18n.client.NumberFormat;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Widget;

public class FormStructureVue extends LayoutContainer implements Rafraichissable {
        
        private Constantes i18nC = null;
        private Mediateur mediateur = null;
        private Modele modele = null ;

        private String mode = "AJOUT";
        private FormPanel structureFormPanneau = null;
        private int tabIndex = 100;
        private TabPanel onglets = null;

        private TabItem identificationOnglet = null;
        private TabItem personnelOnglet = null;
        private TabItem conservationOnglet = null;
        private TabItem valorisationOnglet = null;

        private HiddenField<String> idStructureChp = null;
        
        // Onglet IDENTIFICATION
        private Structure identification;
        private ListStore<Valeur> magazinLstpr = null;
        private ComboBox<Valeur> comboLstpr = null;
        private ListStore<Valeur> magazinLstpu = null;
        private ComboBox<Valeur> comboLstpu = null;
        private ListStore<Valeur> magazinLiStatut = null;
        private ComboBox<Valeur> comboLiStatut = null;
        private ListStore<Valeur> magazinLiFonction = null;
        private ComboBox<Valeur> comboLiFonction = null;
        private ComboBox<InterneValeur> comboAcronyme = null;
        private TextField<String> ihChp = null;
        private TextField<String> mnhnChp = null;
        private ComboBox<InterneValeur> comboTypeStructure = null;
        private TextField<String> nomStructureChp;
        private DateField dateFondationChp;
        private TextArea adrChp;
        private TextField<String> cpChp;
        private TextField<String> villeChp;
        private TextField<String> regionChp;
        private TextField<String> telChp;
        private TextField<String> faxChp;
        private TextField<String> emailChp;
        private TextField<String> urlChp;
        private ListStore<Valeur> magazinPays;
        private ComboBox<Valeur> comboPays;

        // Onglet PERSONNEL
        private StructureAPersonneListe  personnel;
        private NumberField nbreTotalPersonneStructureChp = null;
        private EditorGrid<StructureAPersonne> grillePersonnel = null;
        private ListStore<StructureAPersonne> personnelGrilleMagazin = null;
        private LabelField nbreTotalPersonnelChp = null;
        
        // Onglet CONSERVATION
        private StructureConservation conservation = null;
        private RadioGroup formationMarkRGrpChp;
        private RadioGroup interetFormationMarkRGrpChp;
        private RadioGroup collectionCommuneMarkRGrpChp;
        private RadioGroup accesControleMarkRGrpChp;
        private RadioGroup restaurationMarkRGrpChp;
        private RadioGroup traitementMarkRGrpChp;
        private RadioGroup collectionAcquisitionMarkRGrpChp;
        private RadioGroup echantillonAcquisitionMarkRGrpChp;
        private TextField<String> localStockageAutreChp;
        private TextField<String> meubleStockageAutreChp;
        private TextField<String> parametreStockageAutreChp;
        private TextField<String> collectionAutreAutreChp;
        private TextField<String> autreCollectionAutreChp;
        private TextField<String> opRestauAutreChp;
        private TextField<String> autreMaterielAutreChp;
        private TextField<String> poisonTraitementAutreChp;
        private TextField<String> traitementAutreChp;
        private TextField<String> insecteTraitementAutreChp;
        private TextField<String> actionAutreChp;
        private TextField<String> provenanceRechercheAutreChp;
        private TextField<String> typeRechercheAutreChp;
        private CheckBoxGroup localStockageTrukCacGrpChp = null;
        private ContentPanel localStockageTrukCp = null;
        private CheckBoxGroup meubleStockageTrukCacGrpChp = null;
        private ContentPanel meubleStockageTrukCp = null;
        private CheckBoxGroup parametreStockageTrukCacGrpChp = null;
        private ContentPanel parametreStockageTrukCp = null;
        private ContentPanel collectionAutreTrukCp = null;
        private CheckBoxGroup collectionAutreTrukCacGrpChp = null;
        private CheckBoxGroup opRestauTrukCacGrpChp = null;
        private ContentPanel opRestauTrukCp = null;
        private CheckBoxGroup autreMaterielTrukCacGrpChp = null;
        private ContentPanel autreMaterielTrukCp = null;
        private ContentPanel traitementTrukCp = null;
        private CheckBoxGroup traitementTrukCacGrpChp = null;
        private ContentPanel poisonTraitementTrukCp = null;
        private ContentPanel insecteTraitementTrukCp = null;
        private CheckBoxGroup insecteTraitementTrukCacGrpChp = null;
        private CheckBoxGroup poisonTraitementTrukCacGrpChp = null;
        private ContentPanel autreCollectionTrukCp = null;
        private CheckBoxGroup autreCollectionTrukCacGrpChp = null;
        private ContentPanel provenanceRechercheTrukCp = null;
        private CheckBoxGroup provenanceRechercheTrukCacGrpChp = null;
        private CheckBoxGroup typeRechercheTrukCacGrpChp = null;
        private ContentPanel typeRechercheTrukCp = null;
        private TextField<String> futureActionChp = null;
        private TextField<String> sansMotifAccesChp = null;
        private TextField<String> avecMotifAccesChp = null;
        private TextField<String> formationChp = null;
        private RadioGroup traitementAcquisitionMarkRGrpChp = null;
        private LabelField traitementAcquisitionMarkLabel = null;
        private RadioGroup materielConservationCeRGrpChp = null;

        // Onglet VALORISATION
        private StructureValorisation valorisation = null;
        private RadioGroup actionMarkRGrpChp = null;
        private ContentPanel actionTrukCp = null;
        private CheckBoxGroup actionTrukCacGrpChp = null;
        private RadioGroup futureActionMarkRGrpChp;
        private RadioGroup rechercheMarkRGrpChp;
        private RadioGroup sansMotifAccesMarkRGrpChp;
        private RadioGroup avecMotifAccesMarkRGrpChp;
        private TextField<String> publicationChp;
        private ContentPanel materielConservationCp;



        public FormStructureVue() {
                //+-----------------------------------------------------------------------------------------------------------+         
                // Initialisation de variables
                i18nC = GWT.create(Constantes.class);
                setLayout(new FitLayout());
                modele = Registry.get(RegistreId.MODELE);
                mediateur = Registry.get(RegistreId.MEDIATEUR);
                        
                //+-----------------------------------------------------------------------------------------------------------+
                // Création du panneau du FORMULAIRE GÉNÉRAL
                structureFormPanneau = new FormPanel();
                structureFormPanneau.setFrame(true);
                structureFormPanneau.setIconStyle("icone-form-ajouter");  
                structureFormPanneau.setCollapsible(false);  
                structureFormPanneau.setHeading(i18nC.titreAjoutFormStructurePanneau());
                structureFormPanneau.setButtonAlign(HorizontalAlignment.CENTER);  
                structureFormPanneau.setLayout(new FlowLayout());

                //+-----------------------------------------------------------------------------------------------------------+
                // Création des onglets
                onglets = new TabPanel();
                // NOTE : pour faire apparaître les scrollBar il faut définir la hauteur du panneau d'onglets à 100% (autoHeight ne semble pas fonctionner) 
                onglets.setHeight("100%");
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Onlget formulaire IDENTIFICATION
                onglets.add(creerOngletIdentification());
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Onlget formulaire PERSONNEL
                onglets.add(creerOngletPersonnel());
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Onlget formulaire CONSERVATION
                onglets.add(creerOngletConservation());
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Onlget formulaire VALORISATION
                onglets.add(creerOngletValorisation());
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Gestion du FORMULAIRE GÉNÉRAL
                
                // Sélection de l'onglet par défaut
                onglets.setSelection(personnelOnglet);
                
                // Ajout des onglets au formulaire général
                structureFormPanneau.add(onglets);
                
                // Ajout des boutons au panneau formulaire
                Button annulerBtn = new Button("Annuler");
                annulerBtn.addSelectionListener(new SelectionListener<ComponentEvent>() {

                        @Override
                        public void componentSelected(ComponentEvent ce) {
                                mediateur.clicMenu("Institutions");
                        }
                        
                });
                structureFormPanneau.addButton(annulerBtn);
                Button validerBtn = new Button("Valider");
                validerBtn.addSelectionListener(new SelectionListener<ComponentEvent>() {

                        @Override
                        public void componentSelected(ComponentEvent ce) {
                                soumettreFormulaire();
                        }
                        
                });
                structureFormPanneau.addButton(validerBtn);
                
                // Ajout du panneau Formulaire à la disposition générale
                add(structureFormPanneau);
        }
        
        private void soumettreFormulaire() {
                GWT.log("Soumission du formulaire", null);
                Structure structure = collecterStructureIdentification();
                StructureConservation conservation = collecterStructureConservation();
                StructureValorisation valorisation = collecterStructureValorisation();
                if (mode == "AJOUT") {
                        //mediateur.ajouterStructure(this, structure);
                } else if (mode == "MODIF") {
                        mediateur.modifierStructure(this, structure, conservation, valorisation);
                }
                GWT.log("Info Structure envoyées :\n"+conservation.toString(), null);
        }
        
        private StructureValorisation collecterStructureValorisation() {
                if (valorisationOnglet.getData("acces").equals(false)) {
                        return valorisation;
                } else {
                        // Création de l'objet
                        StructureValorisation valorisationModifie = new StructureValorisation();
                        
                        // ACTION
                        if (actionMarkRGrpChp.getValue() != null) {
                                valorisationModifie.setAction(actionMarkRGrpChp.getValue().getValueAttribute());
                        }
                        
                        // ACTION INFO
                        valorisationModifie.setActionInfo(creerChaineDenormalisee(actionTrukCacGrpChp.getValues()));
                        valorisationModifie.setActionInfo("AUTRE", actionAutreChp.getValue());
                        
                        // PUBLICATION
                        valorisationModifie.setPublication(publicationChp.getValue());
                        
                        // COLLECTION AUTRE
                        valorisationModifie.setCollectionAutre(creerChaineDenormalisee(autreCollectionTrukCacGrpChp.getValues()));
                        valorisationModifie.setCollectionAutre("AUTRE", autreCollectionAutreChp.getValue());
                        
                        // ACTION FUTURE
                        if (futureActionMarkRGrpChp.getValue() != null) {
                                valorisationModifie.setActionFuture(futureActionMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // ACTION FUTURE INFO
                        valorisationModifie.setActionFutureInfo(futureActionChp.getValue());
                        
                        // RECHERCHE
                        if (rechercheMarkRGrpChp.getValue() != null) {
                                valorisationModifie.setRecherche(rechercheMarkRGrpChp.getValue().getValueAttribute());
                        }
                        
                        // RECHERCHE PROVENANCE
                        valorisationModifie.setRechercheProvenance(creerChaineDenormalisee(provenanceRechercheTrukCacGrpChp.getValues()));
                        valorisationModifie.setRechercheProvenance("AUTRE", provenanceRechercheAutreChp.getValue());
                        
                        // RECHERCHE TYPE
                        valorisationModifie.setRechercheType(creerChaineDenormalisee(typeRechercheTrukCacGrpChp.getValues()));
                        valorisationModifie.setRechercheType("AUTRE", typeRechercheAutreChp.getValue());
                        
                        // ACCÈS SANS MOTIF
                        if (sansMotifAccesMarkRGrpChp.getValue() != null) {
                                valorisationModifie.setAccesSansMotif(sansMotifAccesMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // ACCÈS SANS MOTIF INFO
                        valorisationModifie.setAccesSansMotifInfo(sansMotifAccesChp.getValue());
                        
                        // VISITE AVEC MOTIF
                        if (avecMotifAccesMarkRGrpChp.getValue() != null) {
                                valorisationModifie.setVisiteAvecMotif(avecMotifAccesMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // VISITE AVEC MOTIF INFO
                        valorisationModifie.setVisiteAvecMotifInfo(avecMotifAccesChp.getValue());
                        
                        return valorisationModifie;
                }
        }
        
        private void peuplerStructureValorisation() {
                if (valorisation != null) {
                        // ACTION
                        actionMarkRGrpChp.get((valorisation.getAction().equals("1") ? 0 : 1)).setValue(true);
                        
                        // ACTION INFO
                        peuplerCasesACocher(valorisation.getActionInfo(), actionTrukCacGrpChp, actionAutreChp);
                        
                        // PUBLICATION
                        publicationChp.setValue(valorisation.getPublication());
                        
                        // COLLECTION AUTRE
                        peuplerCasesACocher(valorisation.getCollectionAutre(), autreCollectionTrukCacGrpChp, autreCollectionAutreChp);
                        
                        // ACTION FUTURE
                        futureActionMarkRGrpChp.get((valorisation.getActionFuture().equals("1") ? 0 : 1)).setValue(true);
                        
                        // ACTION FUTURE INFO
                        futureActionChp.setValue(valorisation.getActionFutureInfo());
                        
                        // RECHERCHE
                        rechercheMarkRGrpChp.get((valorisation.getRecherche().equals("1") ? 0 : 1)).setValue(true);
                        // RECHERCHE PROVENANCE
                        peuplerCasesACocher(valorisation.getRechercheProvenance(), provenanceRechercheTrukCacGrpChp, provenanceRechercheAutreChp);
                        // RECHERCHE TYPE
                        peuplerCasesACocher(valorisation.getRechercheType(), typeRechercheTrukCacGrpChp, typeRechercheAutreChp);

                        // ACCÈS SANS MOTIF
                        sansMotifAccesMarkRGrpChp.get((valorisation.getAccesSansMotif().equals("1") ? 0 : 1)).setValue(true);
                        // ACCÈS SANS MOTIF INFO
                        sansMotifAccesChp.setValue(valorisation.getAccesSansMotifInfo());
                        
                        // VISITE AVEC MOTIF
                        avecMotifAccesMarkRGrpChp.get((valorisation.getVisiteAvecMotif().equals("1") ? 0 : 1)).setValue(true);
                        // VISITE AVEC MOTIF INFO
                        avecMotifAccesChp.setValue(valorisation.getVisiteAvecMotifInfo());
                        
                        valorisationOnglet.layout();
                }
        }
        
        private StructureConservation collecterStructureConservation() {
                if (conservationOnglet.getData("acces").equals(false)) {
                        return conservation;
                } else {
                        // Création de l'objet
                        StructureConservation conservationModifie = new StructureConservation();
                        
                        // FORMATION
                        if (formationMarkRGrpChp.getValue() != null) {
                                conservationModifie.setFormation(formationMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // FORMATION INFO
                        conservationModifie.setFormationInfo(formationChp.getValue());
                        // FORMATION INTERET
                        if (interetFormationMarkRGrpChp.getValue() != null) {
                                conservationModifie.setFormationInteret(interetFormationMarkRGrpChp.getValue().getValueAttribute());
                        }
                        
                        // STOCKAGE LOCAL
                        conservationModifie.setStockageLocal(creerChaineDenormalisee(localStockageTrukCacGrpChp.getValues()));
                        conservationModifie.setStockageLocal("AUTRE", localStockageAutreChp.getValue());
        
                        // STOCKAGE MEUBLE
                        conservationModifie.setStockageMeuble(creerChaineDenormalisee(meubleStockageTrukCacGrpChp.getValues()));
                        conservationModifie.setStockageMeuble("AUTRE", meubleStockageAutreChp.getValue());
                        
                        // STOCKAGE PAREMETRE
                        conservationModifie.setStockageParametre(creerChaineDenormalisee(parametreStockageTrukCacGrpChp.getValues()));
                        conservationModifie.setStockageParametre("AUTRE", parametreStockageAutreChp.getValue());
                        
                        // COLLECTION COMMUNE
                        if (collectionCommuneMarkRGrpChp.getValue() != null) {
                                conservationModifie.setCollectionCommune(collectionCommuneMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // COLLECTION AUTRE
                        conservationModifie.setCollectionAutre(creerChaineDenormalisee(collectionAutreTrukCacGrpChp.getValues()));
                        conservationModifie.setCollectionAutre("AUTRE", collectionAutreAutreChp.getValue());
                        
                        // ACCÈS CONTROLÉ
                        if (accesControleMarkRGrpChp.getValue() != null) {
                                conservationModifie.setAccesControle(accesControleMarkRGrpChp.getValue().getValueAttribute());
                        }
                        
                        // RESTAURATION
                        if (restaurationMarkRGrpChp.getValue() != null) {
                                conservationModifie.setRestauration(restaurationMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // RESTAURATION OPÉRATION
                        conservationModifie.setRestaurationOperation(creerChaineDenormalisee(opRestauTrukCacGrpChp.getValues()));
                        conservationModifie.setRestaurationOperation("AUTRE", opRestauAutreChp.getValue());
                        
                        // MATERIEL CONSERVATION
                        if (materielConservationCeRGrpChp.getValue() != null) {
                                conservationModifie.setMaterielConservation(materielConservationCeRGrpChp.getValue().getValueAttribute());
                        }
                                
                        // MATERIEL AUTRE
                        conservationModifie.setMaterielAutre(creerChaineDenormalisee(autreMaterielTrukCacGrpChp.getValues()));
                        conservationModifie.setMaterielAutre("AUTRE", autreMaterielAutreChp.getValue());
                        
                        // TRAITEMENT
                        if (traitementMarkRGrpChp.getValue() != null) {
                                conservationModifie.setTraitement(traitementMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // TRAIEMENTS
                        conservationModifie.setTraitements(creerChaineDenormalisee(traitementTrukCacGrpChp.getValues()));
                        conservationModifie.setTraitements("AUTRE", traitementAutreChp.getValue());
                        
                        
                        // ACQUISITION COLLECTION
                        if (collectionAcquisitionMarkRGrpChp.getValue() != null) {
                                conservationModifie.setAcquisitionCollection(collectionAcquisitionMarkRGrpChp.getValue().getValueAttribute());
                        }
                        
                        // ACQUISITION ECHANTILLON
                        if (echantillonAcquisitionMarkRGrpChp.getValue() != null) {
                                conservationModifie.setAcquisitionEchantillon(echantillonAcquisitionMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // ACQUISITION TRAITEMENT
                        if (traitementAcquisitionMarkRGrpChp.getValue() != null) {
                                conservationModifie.setAcquisitionTraitement(traitementAcquisitionMarkRGrpChp.getValue().getValueAttribute());
                        }
                        // ACQUISITION TRAITEMENT POISON
                        conservationModifie.setAcquisitionTraitementPoison(creerChaineDenormalisee(poisonTraitementTrukCacGrpChp.getValues()));
                        conservationModifie.setAcquisitionTraitementPoison("AUTRE", poisonTraitementAutreChp.getValue());
                        // ACQUISITION TRAITEMENT INSECTE
                        conservationModifie.setAcquisitionTraitementInsecte(creerChaineDenormalisee(insecteTraitementTrukCacGrpChp.getValues()));
                        conservationModifie.setAcquisitionTraitementInsecte("AUTRE", insecteTraitementAutreChp.getValue());
                        
                        // Retour de l'objet
                        //GWT.log(conservationLocal.toString(), null);
                        return conservationModifie;
                }
        }
        
        private void peuplerStructureConservation() {
                if (conservation != null) {
                        // FORMATION
                        // Bouton oui, à toujours l'index 0 donc on teste en fonction...
                        formationMarkRGrpChp.get((conservation.getFormation().equals("1") ? 0 : 1)).setValue(true);
                        // FORMATION INFO
                        formationChp.setValue(conservation.getFormationInfo());
                        // FORMATION INTERET
                        interetFormationMarkRGrpChp.get((conservation.getFormationInteret().equals("1") ? 0 : 1)).setValue(true);
        
                        // STOCKAGE LOCAL               
                        peuplerCasesACocher(conservation.getStockageLocal(), localStockageTrukCacGrpChp,localStockageAutreChp);
        
                        // STOCKAGE MEUBLE
                        peuplerCasesACocher(conservation.getStockageMeuble(), meubleStockageTrukCacGrpChp, meubleStockageAutreChp);
        
                        // STOCKAGE PAREMETRE
                        peuplerCasesACocher(conservation.getStockageParametre(), parametreStockageTrukCacGrpChp, parametreStockageAutreChp);
                        
                        // COLLECTION COMMUNE
                        collectionCommuneMarkRGrpChp.get((conservation.getCollectionCommune().equals("1") ? 0 : 1)).setValue(true);
                        // COLLECTION AUTRE
                        peuplerCasesACocher(conservation.getCollectionAutre(), collectionAutreTrukCacGrpChp, collectionAutreAutreChp);
                        
                        // ACCÈS CONTROLÉ
                        accesControleMarkRGrpChp.get((conservation.getAccesControle().equals("1") ? 0 : 1)).setValue(true);
                        
                        // RESTAURATION
                        restaurationMarkRGrpChp.get((conservation.getRestauration().equals("1") ? 0 : 1)).setValue(true);
                        // RESTAURATION OPÉRATION
                        peuplerCasesACocher(conservation.getRestaurationOperation(), opRestauTrukCacGrpChp, opRestauAutreChp);
                        
                        // MATERIEL CONSERVATION
                        peuplerBoutonsRadio(conservation.getMaterielConservation(), materielConservationCeRGrpChp);
                        
                        // MATERIEL AUTRE
                        peuplerCasesACocher(conservation.getMaterielAutre(), autreMaterielTrukCacGrpChp, autreMaterielAutreChp);
                        
                        // TRAITEMENT
                        traitementMarkRGrpChp.get((conservation.getTraitement().equals("1") ? 0 : 1)).setValue(true);
                        // TRAITEMENTS
                        peuplerCasesACocher(conservation.getTraitements(), traitementTrukCacGrpChp, traitementAutreChp);
                        
                        // ACQUISITION COLLECTION
                        collectionAcquisitionMarkRGrpChp.get((conservation.getAcquisitionCollection().equals("1") ? 0 : 1)).setValue(true);
                        
                        // ACQUISITION ECHANTILLON
                        echantillonAcquisitionMarkRGrpChp.get((conservation.getAcquisitionEchantillon().equals("1") ? 0 : 1)).setValue(true);
                        
                        // ACQUISITION TRAITEMENT
                        traitementAcquisitionMarkRGrpChp.get((conservation.getAcquisitionTraitement().equals("1") ? 0 : 1)).setValue(true);
                        
                        // ACQUISITION TRAITEMENT POISON
                        peuplerCasesACocher(conservation.getAcquisitionTraitementPoison(), poisonTraitementTrukCacGrpChp, poisonTraitementAutreChp);
                        // ACQUISITION TRAITEMENT INSECTE
                        peuplerCasesACocher(conservation.getAcquisitionTraitementInsecte(), insecteTraitementTrukCacGrpChp, insecteTraitementAutreChp);
                        
                        conservationOnglet.layout();
                }
        }
        
        private Structure collecterStructureIdentification() {
                if (identificationOnglet.getData("acces").equals(false)) {
                        return identification;
                } else {
                        Structure structure = new Structure();
                        structure.setId(idStructureChp.getValue());
                        structure.setNom(nomStructureChp.getValue());
                        // Récupération de l'acronyme (= identifiant alternatif)
                        structure.setIdAlternatif(null);
                        if (comboAcronyme.getValue() != null) {
                                String typeAcronyme = comboAcronyme.getValue().getAbr();
                                if (typeAcronyme == "IH") {
                                        structure.setIdAlternatif(typeAcronyme+"##"+ihChp.getValue());
                                } else if (typeAcronyme == "MNHN") {
                                        structure.setIdAlternatif(typeAcronyme+"##"+mnhnChp.getValue());
                                }
                        }
                        // Récupération statut de la structure
                        structure.setTypePublic(null);
                        structure.setTypePrive(null);
                        if (comboTypeStructure.getValue() != null) {
                                String typeStructure = comboTypeStructure.getValue().getAbr();
                                if (typeStructure == "stpu" && comboLstpu.getValue() != null) {
                                        structure.setTypePublic(comboLstpu.getValue().getId());
                                } else if (typeStructure == "stpr" && comboLstpr.getValue() != null) {
                                        structure.setTypePrive(comboLstpr.getValue().getId());
                                }
                        }
                        structure.setDateFondation(dateFondationChp.getValue());
                        
                        structure.setAdresse(adrChp.getValue());
                        structure.setCodePostal(cpChp.getValue());
                        structure.setVille(villeChp.getValue());
                        structure.setRegion(regionChp.getValue());
                        structure.setPays(null);
                        if (comboPays.getValue() != null) {
                                structure.setPays(comboPays.getValue().getAbreviation());
                        } else if (comboPays.getRawValue() != "") {
                                structure.setPays(comboPays.getRawValue());
                        }
                        
                        structure.setTelephone(telChp.getValue());
                        structure.setFax(faxChp.getValue());
                        structure.setCourriel(emailChp.getValue());
                        structure.setUrl(Structure.URL_SITE, urlChp.getValue());
                        
                        return structure;
                }
        }
        
        private void peuplerStructureIdentification() {
                if (identification != null) {
                        idStructureChp.setValue(identification.getId());
                        nomStructureChp.setValue(identification.getNom());
                        if (!identification.getIdAlternatif().isEmpty()) {
                                String[] acronyme = identification.getIdAlternatif().split("##");
                                if (acronyme[0].matches("^IH$")) {
                                        comboAcronyme.setValue(InterneValeurListe.getTypeAcronymeIH());
                                        ihChp.setValue(acronyme[1]);
                                } else if (acronyme[0].matches("^MNHN$")) {
                                        comboAcronyme.setValue(InterneValeurListe.getTypeAcronymeMNHN());
                                        mnhnChp.setValue(acronyme[1]);
                                }
                        }
                        if (!identification.getTypePrive().isEmpty()) {
                                if (identification.getTypePrive().matches("^[0-9]+$")) {
                                        comboTypeStructure.setValue(InterneValeurListe.getTypePrivee());
                                        comboLstpr.setValue(comboLstpr.getStore().findModel("id_valeur", identification.getTypePrive()));
                                }
                        } else if (!identification.getTypePublic().isEmpty()) {
                                if (identification.getTypePublic().matches("^[0-9]+$")) {
                                        comboTypeStructure.setValue(InterneValeurListe.getTypePublique());
                                        comboLstpu.setValue(comboLstpu.getStore().findModel("id_valeur", identification.getTypePublic()));
                                }
                        }
                        dateFondationChp.setValue(identification.getDateFondation());
                        
                        adrChp.setValue(identification.getAdresse());
                        cpChp.setValue(identification.getCodePostal());
                        villeChp.setValue(identification.getVille());
                        regionChp.setValue(identification.getRegion());
                        if (identification.getPays().matches("^[A-Z]{2}$")) {
                                comboPays.setValue(comboPays.getStore().findModel("abreviation", identification.getPays()));
                        } else {
                                comboPays.setRawValue(identification.getPays());
                        }
                        
                        telChp.setValue(identification.getTelephone());
                        faxChp.setValue(identification.getFax());
                        emailChp.setValue(identification.getCourriel());
                        urlChp.setValue(identification.getUrl("WEB"));
                        
                        identificationOnglet.layout();
                }
        }
        
        private TabItem creerOngletValorisation() {
                valorisationOnglet = new TabItem();  
                valorisationOnglet.setText("Valorisation");
                valorisationOnglet.setScrollMode(Scroll.AUTO);
                valorisationOnglet.setLayout(creerFormLayout(650, LabelAlign.TOP, null));
                valorisationOnglet.setData("acces", false); // Permet de savoir si l'onblet a été accédé par l'utilisateur
                valorisationOnglet.addListener(Events.Select, new Listener<ComponentEvent>() {
                        public void handleEvent(ComponentEvent be) {
                                // Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter... 
                                valorisationOnglet.setData("acces", true);
                                peuplerStructureValorisation();
                        }
                });
                
                actionMarkRGrpChp = creerChoixUniqueRadioGroupe("action_mark", "ouiNon");
                actionMarkRGrpChp.setFieldLabel("Avez-vous réalisé des actions de valorisation de vos collections botaniques ou avez-vous été sollicités pour la valorisation de ces collections ?");
                valorisationOnglet.add(actionMarkRGrpChp);
                
                
                actionTrukCp = creerChoixMultipleCp("actionValorisation");
                actionTrukCp.hide();
                actionTrukCacGrpChp = new CheckBoxGroup();
                actionTrukCacGrpChp.setFieldLabel("Si oui, lesquelles ?");
                valorisationOnglet.add(actionTrukCp);
                
                publicationChp = new TextArea();
                publicationChp.setFieldLabel("Quelques titres des ouvrages, articles scientifiques, ...");
                valorisationOnglet.add(publicationChp, new FormData(550, 0));
                
                autreCollectionTrukCp = creerChoixMultipleCp("autreCollection");
                autreCollectionTrukCacGrpChp = new CheckBoxGroup();
                autreCollectionTrukCacGrpChp.setFieldLabel("L'organisme dispose-t-il d'autres collections (permettant une valorisation pluridisciplinaire) ?");
                valorisationOnglet.add(autreCollectionTrukCp);
                
                futureActionMarkRGrpChp = creerChoixUniqueRadioGroupe("future_action_mark", "ouiNon");
                futureActionMarkRGrpChp.setFieldLabel("Envisagez vous des actions de valorisation dans le cadre de votre politique culturelle ?");
                valorisationOnglet.add(futureActionMarkRGrpChp);
                
                futureActionChp = new TextArea();
                futureActionChp.setFieldLabel("Si oui, lesquelles ?");
                futureActionChp.hide();
                valorisationOnglet.add(futureActionChp, new FormData(550, 0));
                
                rechercheMarkRGrpChp = creerChoixUniqueRadioGroupe("recherche_mark", "ouiNon");
                rechercheMarkRGrpChp.setFieldLabel("Vos collections botaniques sont-elles utilisées pour des recherches scientifiques ?");
                valorisationOnglet.add(rechercheMarkRGrpChp);
                
                provenanceRechercheTrukCp = creerChoixMultipleCp("continentEtFr");
                provenanceRechercheTrukCp.hide();
                provenanceRechercheTrukCacGrpChp = new CheckBoxGroup();
                provenanceRechercheTrukCacGrpChp.setFieldLabel("Si oui, par des chercheurs (professionnels ou amateurs) de quelle provenance ?");
                valorisationOnglet.add(provenanceRechercheTrukCp);
                
                typeRechercheTrukCp = creerChoixMultipleCp("typeRecherche");
                typeRechercheTrukCp.hide();
                typeRechercheTrukCacGrpChp = new CheckBoxGroup();
                typeRechercheTrukCacGrpChp.setFieldLabel("Et pour quelles recherches ?");
                valorisationOnglet.add(typeRechercheTrukCp);
                
                sansMotifAccesMarkRGrpChp = creerChoixUniqueRadioGroupe("sans_motif_acces_mark", "ouiNon");
                sansMotifAccesMarkRGrpChp.setFieldLabel("Peut-on consulter vos collections botaniques sans motif de recherches scientifiques ?");
                valorisationOnglet.add(sansMotifAccesMarkRGrpChp);
                
                valorisationOnglet.add(sansMotifAccesChp = new TextArea(), new FormData(550, 0));
                sansMotifAccesChp.hide();
                sansMotifAccesChp.setFieldLabel("Si oui, quelles démarches doit-on faire pour les consulter ?");
                
                avecMotifAccesMarkRGrpChp = creerChoixUniqueRadioGroupe("avec_motif_acces_mark", "ouiNon");
                avecMotifAccesMarkRGrpChp.setFieldLabel("Peut-on visiter vos collections botaniques avec des objectifs de recherches scientifiques ?");
                valorisationOnglet.add(avecMotifAccesMarkRGrpChp);
                
                valorisationOnglet.add(avecMotifAccesChp = new TextArea(), new FormData(550, 0));
                avecMotifAccesChp.hide();
                avecMotifAccesChp.setFieldLabel("Si oui, quelles démarches doit-on faire pour les visiter ?");
                
                return valorisationOnglet;
        }
        
        private TabItem creerOngletConservation() {
                conservationOnglet = new TabItem();
                conservationOnglet.setText("Conservation");
                conservationOnglet.setScrollMode(Scroll.AUTO);
                conservationOnglet.setLayout(creerFormLayout(650, LabelAlign.TOP, null));
                conservationOnglet.setData("acces", false);
                conservationOnglet.addListener(Events.Select, new Listener<ComponentEvent>() {  
                        public void handleEvent(ComponentEvent be) {  
                                // Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter...
                                conservationOnglet.setData("acces", true);
                                peuplerStructureConservation();
                        }  
                });  
                
                formationMarkRGrpChp = creerChoixUniqueRadioGroupe("formation_mark", "ouiNon");
                formationMarkRGrpChp.setFieldLabel("Le personnel s'occupant des collections a-t-il suivi des formations en conservations ?");
                conservationOnglet.add(formationMarkRGrpChp);
                
                formationChp = new TextField<String>();
                formationChp.hide();
                formationChp.setFieldLabel("Si oui, lesquelles ?");
                conservationOnglet.add(formationChp);
                
                interetFormationMarkRGrpChp = creerChoixUniqueRadioGroupe("interet_formation_mark", "ouiNon");
                interetFormationMarkRGrpChp.setFieldLabel("Seriez vous intéressé par une formation à la conservation et à la restauration d'herbier ?");
                conservationOnglet.add(interetFormationMarkRGrpChp);
                
                localStockageTrukCp = creerChoixMultipleCp("localStockage");
                localStockageTrukCacGrpChp = new CheckBoxGroup();
                localStockageTrukCacGrpChp.setFieldLabel("Avez vous des locaux spécifiques de stockage des collections botaniques ?");
                conservationOnglet.add(localStockageTrukCp);
                
                meubleStockageTrukCp = creerChoixMultipleCp("meubleStockage");
                meubleStockageTrukCacGrpChp = new CheckBoxGroup();
                meubleStockageTrukCacGrpChp.setFieldLabel("Avez vous des meubles spécifiques au stockage des collections botaniques ?");
                conservationOnglet.add(meubleStockageTrukCp);
                
                parametreStockageTrukCp = creerChoixMultipleCp("parametreStockage");
                parametreStockageTrukCacGrpChp = new CheckBoxGroup();
                parametreStockageTrukCacGrpChp.setFieldLabel("Quels paramètres maîtrisez vous ?");
                conservationOnglet.add(parametreStockageTrukCp);
                
                collectionCommuneMarkRGrpChp = creerChoixUniqueRadioGroupe("collection_commune_mark", "ouiNon");
                collectionCommuneMarkRGrpChp.setFieldLabel("Les collections botaniques sont-elles conservées avec d'autres collections  dans les mêmes locaux (problème de conservation en commun) ?");
                conservationOnglet.add(collectionCommuneMarkRGrpChp);
                
                collectionAutreTrukCp = creerChoixMultipleCp("autreCollection");
                collectionAutreTrukCacGrpChp = new CheckBoxGroup();
                collectionAutreTrukCacGrpChp.setFieldLabel("Si oui, lesquelles ?");
                collectionAutreTrukCp.hide();
                conservationOnglet.add(collectionAutreTrukCp);
                
                accesControleMarkRGrpChp = creerChoixUniqueRadioGroupe("mark_acces_controle", "ouiNon");
                accesControleMarkRGrpChp.setFieldLabel("L'accès à vos collections botanique est-il contrôlé (ex. : manipulation réservées à des personnes compétentes) ?");
                conservationOnglet.add(accesControleMarkRGrpChp);
                
                restaurationMarkRGrpChp = creerChoixUniqueRadioGroupe("restauration_mark", "ouiNon");
                restaurationMarkRGrpChp.setFieldLabel("Effectuez vous des opérations de restauration ou de remise en état de vos collections botaniques ?");
                conservationOnglet.add(restaurationMarkRGrpChp);
                
                opRestauTrukCp = creerChoixMultipleCp("opRestau");
                opRestauTrukCacGrpChp = new CheckBoxGroup();
                opRestauTrukCacGrpChp.setFieldLabel("Si oui, lesquelles ?");
                opRestauTrukCp.hide();
                conservationOnglet.add(opRestauTrukCp);
                
                // Création d'un ContentPanel vide et du groupe de bouton radio
                // Le groupe de bouton radio recevra les boutons au moment de la réception des données (rafraichir()) et ser à ce moment là ajouter au ContenetPanel
                materielConservationCp = creerChoixMultipleCp("onep");
                conservationOnglet.add(materielConservationCp);
                materielConservationCeRGrpChp = creerChoixUniqueRadioGroupe("materiel_conservation_ce", "onep");
                materielConservationCeRGrpChp.setFieldLabel("Utilisez vous du matériel de conservation ?");
                materielConservationCeRGrpChp.setToolTip(new ToolTipConfig("Matériel de conservation", "matériel spécialisé pour la conservation des archives ou du patrimoine fragile. Ce matériel possède des propriétés mécaniques et chimiques qui font qu'il résiste dans le temps et que sa dégradation n'entraîne pas de dommages sur le matériel qu'il aide à conserver. Exemples : papier neutre, papier gommé, etc..."));
                
                autreMaterielTrukCp = creerChoixMultipleCp("autreMateriel");
                autreMaterielTrukCp.hide();
                autreMaterielTrukCacGrpChp = new CheckBoxGroup();
                autreMaterielTrukCacGrpChp.setFieldLabel("Si non, qu'utilisez vous comme matériel ?");
                conservationOnglet.add(autreMaterielTrukCp);
                
                traitementMarkRGrpChp = creerChoixUniqueRadioGroupe("traitement_mark", "ouiNon");
                traitementMarkRGrpChp.setFieldLabel("Réalisez vous actuellement des traitements globaux contre les insectes ?");
                conservationOnglet.add(traitementMarkRGrpChp);
                
                traitementTrukCp = creerChoixMultipleCp("insecteTraitement");
                traitementTrukCp.hide();
                traitementTrukCacGrpChp = new CheckBoxGroup();
                traitementTrukCacGrpChp.setFieldLabel("Si oui, lesquels ?");
                conservationOnglet.add(traitementTrukCp);
                
                collectionAcquisitionMarkRGrpChp = creerChoixUniqueRadioGroupe("collection_acquisition_mark", "ouiNon");
                collectionAcquisitionMarkRGrpChp.setFieldLabel("Actuellement, vos collections botaniques s'accroissent-elles de nouvelles acquisitions ?");
                conservationOnglet.add(collectionAcquisitionMarkRGrpChp);
                
                echantillonAcquisitionMarkRGrpChp = creerChoixUniqueRadioGroupe("echantillon_acquisition_mark", "ouiNon");
                echantillonAcquisitionMarkRGrpChp.setFieldLabel("Actuellement, mettez vous en herbier de nouveaux échantillons ?");
                conservationOnglet.add(echantillonAcquisitionMarkRGrpChp);

                traitementAcquisitionMarkRGrpChp = creerChoixUniqueRadioGroupe("traitement_acquisition_mark", "ouiNon");
                traitementAcquisitionMarkRGrpChp.hide();
                traitementAcquisitionMarkRGrpChp.setFieldLabel("Si oui, faites-vous un traitement contre les insectes avant l'intégration dans vos collections ?");
                conservationOnglet.add(traitementAcquisitionMarkRGrpChp);
                
                traitementAcquisitionMarkLabel = new LabelField();
                traitementAcquisitionMarkLabel.hide();
                traitementAcquisitionMarkLabel.setFieldLabel("Si oui, lesquels ?");
                conservationOnglet.add(traitementAcquisitionMarkLabel);
                
                poisonTraitementTrukCp = creerChoixMultipleCp("poisonTraitement");
                poisonTraitementTrukCp.hide();
                poisonTraitementTrukCacGrpChp = new CheckBoxGroup();
                poisonTraitementTrukCacGrpChp.setFieldLabel("Empoisonnement");
                poisonTraitementTrukCacGrpChp.setLabelStyle("font-weight:normal;text-decoration:underline;");
                poisonTraitementTrukCacGrpChp.setLabelSeparator("");
                conservationOnglet.add(poisonTraitementTrukCp);
                
                insecteTraitementTrukCp = creerChoixMultipleCp("insecteTraitement");
                insecteTraitementTrukCp.hide();
                insecteTraitementTrukCacGrpChp = new CheckBoxGroup();
                insecteTraitementTrukCacGrpChp.setLabelStyle("font-weight:normal;text-decoration:underline;");
                insecteTraitementTrukCacGrpChp.setLabelSeparator("");
                insecteTraitementTrukCacGrpChp.setFieldLabel("Désinsectisation");
                conservationOnglet.add(insecteTraitementTrukCp);
                
                return conservationOnglet;
        }
        
        
        private void peuplerStructurePersonnel() {
                if (identification != null) {
                        // NBRE PERSONNE
                        nbreTotalPersonneStructureChp.setValue(identification.getNbrePersonne());
                }
                
                if (personnel != null) {
                        
                        ArrayList<StructureAPersonne> personnes = new ArrayList<StructureAPersonne>();
                        for (Iterator<String> it = personnel.keySet().iterator(); it.hasNext();) {
                                String index = it.next();
                                if (magazinLiFonction != null && ((String) personnel.get(index).getFonction()).matches("^[0-9]+$")) {
                                        GWT.log(personnel.get(index).getFonction(), null);
                                        personnel.get(index).set("fonction", magazinLiFonction.findModel("id_valeur", personnel.get(index).getFonction()).getNom());
                                } else {
                                        personnel.get(index).set("fonction", personnel.get(index).getFonction());
                                }
                                personnes.add(personnel.get(index));
                        }
                        personnelGrilleMagazin.removeAll();
                        personnelGrilleMagazin.add(personnes);
                        
                        grillePersonnel.getColumnModel().getColumn(1).getEditor().fireEvent(Events.StateSave);
                        /*
                        int nbreLigne = personnelGrilleMagazin.getCount();
                        for (int i = 0; i < nbreLigne; i++) {
                                
                        }
                        */
                        personnelOnglet.layout();
                }
        }
        
        private TabItem creerOngletPersonnel() {
                personnelOnglet = new TabItem();
                
                personnelOnglet.setText("Personnel");
                personnelOnglet.setScrollMode(Scroll.AUTO);
                personnelOnglet.setLayout(creerFormLayout(400, LabelAlign.LEFT, null));
                personnelOnglet.setData("acces", false); // Permet de savoir si l'onblet a été accédé par l'utilisateur
                personnelOnglet.addListener(Events.Select, new Listener<ComponentEvent>() {
                        public void handleEvent(ComponentEvent be) {
                                // Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter...
                                personnelOnglet.setData("acces", true);
                                peuplerStructurePersonnel();
                        }

                });
                
                nbreTotalPersonneStructureChp = new NumberField();  
                nbreTotalPersonneStructureChp.setFieldLabel("Nombre de personne travaillant dans l'institution");
                nbreTotalPersonneStructureChp.setFormat(NumberFormat.getFormat("#"));
                nbreTotalPersonneStructureChp.setToolTip("Ce champ doit contenir un nombre");
                personnelOnglet.add(nbreTotalPersonneStructureChp);
                
                personnelOnglet.add(this.creerGrillePersonnel());
                
                nbreTotalPersonnelChp = new LabelField();  
                nbreTotalPersonnelChp.setFieldLabel("Nombre de personne travaillant sur les collections");
                nbreTotalPersonnelChp.setLabelSeparator(":");
                nbreTotalPersonnelChp.setValue(""+grillePersonnel.getStore().getCount());
                personnelOnglet.add(nbreTotalPersonnelChp);

                return personnelOnglet;
        }
        
        private ContentPanel creerGrillePersonnel() {  
                ContentPanel cp = new ContentPanel();
                
                List<StructureAPersonne> personnes = new ArrayList<StructureAPersonne>();
                personnes.add(new StructureAPersonne(Valeur.FONCTION_DIRECTEUR));
                personnes.add(new StructureAPersonne(Valeur.FONCTION_CONSERVATEUR));
                
                personnelGrilleMagazin = new ListStore<StructureAPersonne>();  
                personnelGrilleMagazin.add(personnes);  

                List<ColumnConfig> configs = new ArrayList<ColumnConfig>();

                CheckBoxSelectionModel<StructureAPersonne> sm = new CheckBoxSelectionModel<StructureAPersonne>();
                configs.add(sm.getColumn());
                
                ColumnConfig column = new ColumnConfig("fonction", "Fonction", 100);
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId("fonction"));
                magazinLiFonction = new ListStore<Valeur>();
                magazinLiFonction.add(new ArrayList<Valeur>());
                
                comboLiFonction = new ComboBox<Valeur>();  
                comboLiFonction.setTriggerAction(TriggerAction.ALL);  
                comboLiFonction.setEditable(true);
                comboLiFonction.setDisplayField("nom");
                //comboLiStatut.setEmptyText("Sélectionez une fonction...");
                comboLiFonction.setStore(magazinLiFonction);
                /*
                comboLiFonction.addListener(Events.Blur, new Listener<BaseEvent>() {

                        @Override
                        public void handleEvent(BaseEvent be) {
                                //grillePersonnel..comboLiFonction.getRawValue();
                                
                        }
                        
                });*/
                
                CellEditor fonctionEditor = new CellEditor(comboLiFonction) {  
                        @Override  
                        public Object preProcessValue(Object valeur) {  
                                if (valeur == null) {
                                        GWT.log("pre null :", null);
                                        return null; 
                                }
                                GWT.log("pre : "+valeur.toString(), null);
                                Object retour = null;
                                if (((String) valeur).matches("^[0-9]+$")) {
                                        Valeur valeurRecherche = comboLiFonction.getStore().findModel("id_valeur", (String) valeur);
                                        if (valeurRecherche != null) {
                                                retour = valeurRecherche;
                                                GWT.log("pre - retour valeur par chiffre : \n"+retour.toString(), null);
                                        } else {
                                                this.getField().setRawValue((String) valeur);
                                                retour = null;
                                        }
                                } else if (valeur instanceof String) {
                                        this.getField().setRawValue((String) valeur);
                                        retour = null;
                                } else {
                                        retour = comboLiFonction.getStore().findModel("nom", (String) valeur);
                                        GWT.log("pre - retour valeur par chaine : \n"+retour.toString(), null);
                                }
                                
                                return retour;
                        }  
                        
                        @Override  
                        public Object postProcessValue(Object valeur) {  
                                if (valeur == null) {
                                        // Si la combobox n'a pas été utilisé, nous renvoyons la valeur brute saisie par l'utilisateur
                                        GWT.log("post raw : \n"+this.getField().getRawValue(), null);
                                        String retour = this.getField().getRawValue();
                                        if (retour.matches("^[0-9]+$")) {
                                                GWT.log("ici", null);
                                                Valeur valeurRecherche = comboLiFonction.getStore().findModel("id_valeur", (String) retour);
                                                if (valeurRecherche != null) {
                                                        retour = valeurRecherche.getNom();
                                                }
                                        }
                                        return retour;
                                } else {
                                        GWT.log("post : \n"+valeur.toString(), null);
                                        String nom = "";
                                        if (valeur instanceof Valeur) {
                                                nom = (((Valeur) valeur).getNom());
                                                GWT.log("la "+nom, null);
                                        }
                                        return nom;
                                }
                        }
                };
                column.setEditor(fonctionEditor);
                configs.add(column);
                
                column = new ColumnConfig();  
                column.setId("prenom");  
                column.setHeader("Prénom");
                column.setWidth(100);
                TextField<String> prenomChp = new TextField<String>();  
                prenomChp.setAllowBlank(false);
                prenomChp.getMessages().setBlankText("Ce champ est obligatoire.");
                prenomChp.setAutoValidate(true);  
                column.setEditor(new CellEditor(prenomChp));
                configs.add(column);  
                
                column = new ColumnConfig();  
                column.setId("nom");
                column.setHeader("Nom");
                column.setWidth(100);
                TextField<String> nomChp = new TextField<String>();  
                nomChp.setAllowBlank(false);
                nomChp.getMessages().setBlankText("Ce champ est obligatoire.");
                nomChp.setAutoValidate(true);  
                column.setEditor(new CellEditor(nomChp));
                configs.add(column);  

                column = new ColumnConfig("telephone", "Téléphone fixe", 100);
                TextField<String> telChp = new TextField<String>();  
                column.setEditor(new CellEditor(telChp));
                configs.add(column);

                column = new ColumnConfig("fax", "Fax", 100);
                TextField<String> faxChp = new TextField<String>();  
                column.setEditor(new CellEditor(faxChp));
                configs.add(column);
                
                column = new ColumnConfig("courriel", "Courriel", 100);
                TextField<String> emailChp = new TextField<String>();  
                column.setEditor(new CellEditor(emailChp));
                configs.add(column);
                
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId("statut"));
                magazinLiStatut = new ListStore<Valeur>();
                magazinLiStatut.add(new ArrayList<Valeur>());
                
                comboLiStatut = new ComboBox<Valeur>();  
                comboLiStatut.setTriggerAction(TriggerAction.ALL);  
                comboLiStatut.setEditable(false);
                comboLiStatut.setDisplayField("nom");
                comboLiStatut.setEmptyText("Sélectionez un statut...");
                comboLiStatut.setStore(magazinLiStatut);
                
                CellEditor statutEditor = new CellEditor(comboLiStatut) {  
                        @Override  
                        public Object preProcessValue(Object value) {  
                                if (value == null) {  
                                        return value;  
                                }
                                //GWT.log("pre : "+value.toString(), null);
                                return comboLiStatut.getStore().findModel("nom", (String) value);  
                        }  
                        
                        @Override  
                        public Object postProcessValue(Object value) {  
                                if (value == null) {  
                                        return value;  
                                }
                                //GWT.log("post : "+value.toString(), null);
                                return ((Valeur) value).get("nom");  
                        }  
                };  
                column = new ColumnConfig("statut", "Statut", 100);
                column.setEditor(statutEditor);
                configs.add(column);
                
                column = new ColumnConfig("travail", "Temps travail", 100);
                column.setNumberFormat(NumberFormat.getFormat("##"));
                NumberField tpsWChp = new NumberField();
                tpsWChp.setFormat(NumberFormat.getFormat("##"));
                tpsWChp.setToolTip("Ce champ doit contenir un nombre");
                column.setEditor(new CellEditor(tpsWChp));
                configs.add(column);
                
                column = new ColumnConfig("specialite", "Spécialité principale", 150);
                TextField<String> speChp = new TextField<String>();  
                column.setEditor(new CellEditor(speChp));
                configs.add(column);
                
                CheckColumnConfig checkColumn = new CheckColumnConfig("contact", "Contact ?", 60);
                configs.add(checkColumn);
                
                
                cp.setHeading("Personnes travaillant sur les collections");
                cp.setIconStyle("icone-table");
                cp.setScrollMode(Scroll.AUTO);
                cp.setLayout(new FitLayout());
                cp.setSize(1100, 200);
                cp.setFrame(true);
                
                ToolBar toolBar = new ToolBar();  
                
                TextToolItem ajouterPersonnelBtn = new TextToolItem("Ajouter", "icone-vcard-ajouter");
                ajouterPersonnelBtn.addSelectionListener(new SelectionListener<ToolBarEvent>() {  
                        @Override  
                        public void componentSelected(ToolBarEvent ce) {  
                                StructureAPersonne personne = new StructureAPersonne();  
                                grillePersonnel.stopEditing();  
                                personnelGrilleMagazin.insert(personne, 0);  
                                grillePersonnel.startEditing(0, 0);
                                // Mise à jour du nombre de personnel travaillant sur les collections
                                nbreTotalPersonnelChp.setValue(""+grillePersonnel.getStore().getCount());
                                // Activation du bouton supprimer si la grille contient un élément
                                if (grillePersonnel.getStore().getCount() > 0) {  
                                        ce.component.enable();  
                                }
                        }  
                });
                toolBar.add(ajouterPersonnelBtn);
                toolBar.add(new SeparatorToolItem());
                TextToolItem supprimerPersonnelBtn = new TextToolItem("Supprimer", "icone-vcard-supprimer");
                supprimerPersonnelBtn.addSelectionListener(new SelectionListener<ToolBarEvent>() {  
                        @Override
                        public void componentSelected(ToolBarEvent ce) {
                                grillePersonnel.getStore().remove(grillePersonnel.getStore().getAt(0));
                                // Mise à jour du nombre de personnel travaillant sur les collections
                                nbreTotalPersonnelChp.setValue(""+grillePersonnel.getStore().getCount());
                                // Désactivation du bouton supprimer si la grille contient plus d'élément
                                if (grillePersonnel.getStore().getCount() == 0) {  
                                        ce.item.disable();  
                                }  
                        }   
                });
                toolBar.add(supprimerPersonnelBtn);  
                cp.setTopComponent(toolBar);  

                ColumnModel cm = new ColumnModel(configs);
                
                grillePersonnel = new EditorGrid<StructureAPersonne>(personnelGrilleMagazin, cm);  
                grillePersonnel.setBorders(true);
                grillePersonnel.setSelectionModel(sm);
                grillePersonnel.addPlugin(sm);
                grillePersonnel.addPlugin(checkColumn);
                grillePersonnel.setAutoExpandColumn("specialite");
                grillePersonnel.setStripeRows(true);
                grillePersonnel.setTrackMouseOver(true);
                cp.add(grillePersonnel);
                        
                return cp;
        }  
        
        private TabItem creerOngletIdentification() {
                //+-----------------------------------------------------------------------------------------------------------+
                // Onlget formulaire IDENTIFICATION
                identificationOnglet = new TabItem();
                identificationOnglet.setId("identification");
                identificationOnglet.setText("Identification");
                identificationOnglet.setLayout(new FormLayout());
                identificationOnglet.setData("acces", false);
                identificationOnglet.addListener(Events.Select, new Listener<ComponentEvent>() {  
                        public void handleEvent(ComponentEvent be) {  
                                // Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter...
                                identificationOnglet.setData("acces", true);
                                peuplerStructureIdentification();
                        }  
                });
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Champs cachés
                idStructureChp = new HiddenField<String>();
                
                //+-----------------------------------------------------------------------------------------------------------+
                // Fieldset IDENTITÉ
                FieldSet fieldSetIdentite = new FieldSet();
                fieldSetIdentite.setHeading("Identité");
                fieldSetIdentite.setCollapsible(true);
                fieldSetIdentite.setLayout(creerFormLayout(200, LabelAlign.LEFT, 4));
                
                nomStructureChp = new TextField<String>();
                nomStructureChp.setTabIndex(100);
                nomStructureChp.setFieldLabel("Nom de la structure");
                nomStructureChp.setAllowBlank(false);
                nomStructureChp.getMessages().setBlankText("Ce champ est obligatoire.");
                fieldSetIdentite.add(nomStructureChp, new FormData(450, 0));
                
                // Création du sous-formulaire : Acronyme
                LayoutContainer ligne = new LayoutContainer();  
                ligne.setLayout(new ColumnLayout());
                LayoutContainer gauche = new LayoutContainer();
                gauche.setLayout(creerFormLayout(200, LabelAlign.LEFT, 0));
                LayoutContainer droite = new LayoutContainer();
                droite.setLayout(creerFormLayout(0, null, 0));
                
                ListStore<InterneValeur> acronymes = new ListStore<InterneValeur>();  
                acronymes.add(InterneValeurListe.getTypeAcronyme()); 
                
                comboAcronyme = new ComboBox<InterneValeur>();
                comboAcronyme.setTabIndex(101);
                comboAcronyme.setEmptyText("Sélectioner un type d'acronyme...");
                comboAcronyme.setFieldLabel("Acronymes");
                comboAcronyme.setDisplayField("nom");
                comboAcronyme.setStore(acronymes);
                comboAcronyme.setEditable(false);
                comboAcronyme.setTypeAhead(true);  
                comboAcronyme.setTriggerAction(TriggerAction.ALL);
                comboAcronyme.addSelectionChangedListener(new SelectionChangedListener<InterneValeur>() {
                        @Override
                        public void selectionChanged(SelectionChangedEvent<InterneValeur> se) {
                                String acronymeAbr = se.getSelectedItem().getAbr();
                                if (acronymeAbr.equals("IH")) {
                                        mnhnChp.hide();
                                        ihChp.show();
                                } else if (acronymeAbr.equals("MNHN")) {
                                        ihChp.hide();
                                        mnhnChp.show();
                                } else if (acronymeAbr.equals("")) {
                                        ihChp.hide();
                                        mnhnChp.hide();
                                        comboAcronyme.clearSelections();
                                }
                        }
        });
                gauche.add(comboAcronyme);
                
                ihChp = new TextField<String>();  
                //ihChp.setEmptyText("Index Herbariorum");
                ihChp.setTabIndex(102);
                ihChp.setLabelSeparator("");
                ihChp.setToolTip("Index Herbariorum : herbier de plus de 5000 échantillons");
                ihChp.hide();
                droite.add(ihChp);
                
                mnhnChp = new TextField<String>();
                mnhnChp.setTabIndex(103);
                //mnhnChp.setEmptyText("MNHN");
                mnhnChp.setLabelSeparator("");
                mnhnChp.setToolTip("Acronyme MNHN : herbier de moins de 5000 échantillons");
                mnhnChp.hide();
                droite.add(mnhnChp);
                
                ligne.add(gauche, new ColumnData(0.5));  
                ligne.add(droite, new ColumnData(0.5));
                fieldSetIdentite.add(ligne);
                
                // Création du sous-formulaire : Type de Structure
                LayoutContainer ligneTs = new LayoutContainer();  
                ligneTs.setLayout(new ColumnLayout());
                
                LayoutContainer gaucheTs = new LayoutContainer();
                gaucheTs.setLayout(creerFormLayout(200, LabelAlign.LEFT, 0));
                
                LayoutContainer droiteTs = new LayoutContainer();
                droiteTs.setLayout(creerFormLayout(0, null, 0));
                
                ListStore<InterneValeur> typesStructure = new ListStore<InterneValeur>();  
                typesStructure.add(InterneValeurListe.getTypeStructure());
                
                comboTypeStructure = new ComboBox<InterneValeur>();
                comboTypeStructure.setTabIndex(104);
                comboTypeStructure.setEmptyText("Sélectioner un type de structure...");
                comboTypeStructure.setFieldLabel("Statut des structures");
                comboTypeStructure.setDisplayField("nom");
                comboTypeStructure.setStore(typesStructure);
                comboTypeStructure.setEditable(false);
                comboTypeStructure.setTypeAhead(true);  
                comboTypeStructure.setTriggerAction(TriggerAction.ALL);
                comboTypeStructure.addSelectionChangedListener(new SelectionChangedListener<InterneValeur>() {
                        @Override
                        public void selectionChanged(SelectionChangedEvent<InterneValeur> se) {
                                String typeAbr = se.getSelectedItem().getAbr();
                                if (typeAbr.equals("stpu")) {
                                        comboLstpr.hide();
                                        comboLstpu.show();
                                } else if (typeAbr.equals("stpr")) {
                                        comboLstpu.hide();
                                        comboLstpr.show();
                                } else if (typeAbr.equals("")) {
                                        comboLstpr.hide();
                                        comboLstpu.hide();
                                        comboTypeStructure.clearSelections();
                                }
                        }
        });
                gaucheTs.add(comboTypeStructure);
                
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId("stpu"));
                magazinLstpu = new ListStore<Valeur>();
                magazinLstpu.add(new ArrayList<Valeur>());
                comboLstpu = new ComboBox<Valeur>();
                comboLstpu.setTabIndex(105);
                //comboLstpu.setFieldLabel("Statut des structures publiques");
                comboLstpu.setLabelSeparator("");
                comboLstpu.setDisplayField("nom");
                comboLstpu.setEditable(false);
                comboLstpu.setTriggerAction(TriggerAction.ALL);
                comboLstpu.setStore(magazinLstpu);
                comboLstpu.hide();
                droiteTs.add(comboLstpu);
                
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId("stpr"));
                magazinLstpr = new ListStore<Valeur>();
                magazinLstpr.add(new ArrayList<Valeur>());
                comboLstpr = new ComboBox<Valeur>();
                comboLstpr.setTabIndex(106);
                //comboLstpr.setFieldLabel("Statut des structures privées");
                comboLstpr.setLabelSeparator("");
                comboLstpr.setDisplayField("nom");
                comboLstpr.setEditable(false);
                comboLstpr.setTriggerAction(TriggerAction.ALL);
                comboLstpr.setStore(magazinLstpr);
                comboLstpr.hide();
                droiteTs.add(comboLstpr);
                
                ligneTs.add(gaucheTs, new ColumnData(0.5));  
                ligneTs.add(droiteTs, new ColumnData(0.5));
                fieldSetIdentite.add(ligneTs);
                
                dateFondationChp = new DateField();
                dateFondationChp.setTabIndex(107);
                dateFondationChp.setFieldLabel("Date de fondation");
                dateFondationChp.getPropertyEditor().getFormat();
                dateFondationChp.getPropertyEditor().setFormat(DateTimeFormat.getFormat("dd/MM/yyyy"));
                dateFondationChp.getMessages().setInvalidText("La valeur saisie n'est pas une date valide. La date doit être au format «jj/mm/aaaa».");
                fieldSetIdentite.add(dateFondationChp);
                
                identificationOnglet.add(fieldSetIdentite);

                //+-----------------------------------------------------------------------------------------------------------+         
                // Fieldset ADRESSE
                LayoutContainer principalFdAdresse = new LayoutContainer();  
                principalFdAdresse.setLayout(new ColumnLayout());
                
                LayoutContainer gaucheFdAdresse = new LayoutContainer();
                gaucheFdAdresse.setLayout(creerFormLayout(100, LabelAlign.LEFT, 0));
                
                LayoutContainer droiteFdAdresse = new LayoutContainer();
                droiteFdAdresse.setLayout(creerFormLayout(100, LabelAlign.LEFT, 0));
                
                FieldSet fieldSetAdresse = new FieldSet();
                fieldSetAdresse.setHeading("Adresse");
                fieldSetAdresse.setCollapsible(true);
                
                fieldSetAdresse.setLayout(creerFormLayout(100, LabelAlign.LEFT, 4));
                
                adrChp = new TextArea();
                adrChp.setTabIndex(108);
                adrChp.setFieldLabel("Adresse");
                fieldSetAdresse.add(adrChp, new FormData(550, 0));
                
                cpChp = new TextField<String>();
                cpChp.setTabIndex(109);
                cpChp.setFieldLabel("Code postal");
                gaucheFdAdresse.add(cpChp);
                
                villeChp = new TextField<String>();
                villeChp.setTabIndex(110);
                villeChp.setFieldLabel("Ville");
                droiteFdAdresse.add(villeChp);
                
                regionChp = new TextField<String>();
                regionChp.setTabIndex(111);
                regionChp.setFieldLabel("Région");
                gaucheFdAdresse.add(regionChp);
                
                //paysChp = new TextField<String>();
                //paysChp.setTabIndex(112);
                //paysChp.setFieldLabel("Pays");
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId("pays"));
                magazinPays = new ListStore<Valeur>();
                magazinPays.add(new ArrayList<Valeur>());
                comboPays = new ComboBox<Valeur>();
                comboPays.setTabIndex(112);
                comboPays.setFieldLabel("Pays");
                comboPays.setEmptyText("Sélectioner un pays...");
                comboPays.setEditable(true);
                comboPays.setLabelSeparator("");
                comboPays.setDisplayField("nom");
                comboPays.setTemplate(getTemplatePays());
                comboPays.setTypeAhead(true);
                comboPays.setTriggerAction(TriggerAction.ALL);
                comboPays.setStore(magazinPays);
                droiteFdAdresse.add(comboPays);
                
                principalFdAdresse.add(gaucheFdAdresse, new ColumnData(.5));
                principalFdAdresse.add(droiteFdAdresse, new ColumnData(.5));
                fieldSetAdresse.add(principalFdAdresse);
                identificationOnglet.add(fieldSetAdresse);

                //+-----------------------------------------------------------------------------------------------------------+
                // Fieldset TÉLÉPHONE et EMAIL
                LayoutContainer principalFdTelMail = new LayoutContainer();  
                principalFdTelMail.setLayout(new ColumnLayout());
                
                LayoutContainer gaucheFdTelMail = new LayoutContainer();
                gaucheFdTelMail.setLayout(creerFormLayout(100, LabelAlign.LEFT, 0));
                
                LayoutContainer droiteFdTelMail = new LayoutContainer();
                droiteFdTelMail.setLayout(creerFormLayout(100, LabelAlign.LEFT, 0));
                
                FieldSet fieldSetTelMail = new FieldSet();
                fieldSetTelMail.setHeading("Communication");
                fieldSetTelMail.setCollapsible(true);
                
                fieldSetTelMail.setLayout(creerFormLayout(200, LabelAlign.LEFT, 4));
                                
                telChp = new TextField<String>();
                telChp.setTabIndex(113);
                telChp.setFieldLabel("Téléphone");
                gaucheFdTelMail.add(telChp);
                
                faxChp = new TextField<String>();
                faxChp.setTabIndex(114);
                faxChp.setFieldLabel("Fax");
                droiteFdTelMail.add(faxChp);
                
                emailChp = new TextField<String>();
                emailChp.setTabIndex(115);
                emailChp.setFieldLabel("Courriel");
                emailChp.setToolTip("Saisir le courriel de l'organisation, pas de courriel individuel. Ex. : accueil@organisation.org");
                gaucheFdTelMail.add(emailChp);
                
                urlChp = new TextField<String>();
                urlChp.setTabIndex(116);
                urlChp.setFieldLabel("Site web");
                droiteFdTelMail.add(urlChp);
                
                principalFdTelMail.add(gaucheFdTelMail, new ColumnData(.5));
                principalFdTelMail.add(droiteFdTelMail, new ColumnData(.5));
                fieldSetTelMail.add(principalFdTelMail);
                identificationOnglet.add(fieldSetTelMail);
                
                return identificationOnglet;
        }
        
        private native String getTemplatePays() /*-{ 
                return  [ 
                '<tpl for=".">', 
                '<div class="x-combo-list-item">{nom} ({abreviation})</div>', 
                '</tpl>' 
                ].join(""); 
                }-*/;
        
        private void peuplerCasesACocher(String donnees, CheckBoxGroup groupeCac, TextField<String> champAutre) {
                String[] valeurs = donnees.split(";;");
                for (int i = 0; i < valeurs.length; i++) {
                        if (valeurs[i].startsWith("AUTRE##")) {
                                champAutre.setValue(valeurs[i].replaceFirst("^AUTRE##", ""));
                        } else {
                                List<CheckBox> cases = groupeCac.getAll();
                                for (int j = 0; j < cases.size(); j++) {
                                        if (cases.get(j).getId().equals("val-"+valeurs[i])) {
                                                cases.get(j).setValue(true);
                                        }
                                }
                        }
                }
        }
        
        private void peuplerBoutonsRadio(String valeur, RadioGroup groupeBr) {
                List<Radio> boutons = groupeBr.getAll();
                String id = valeur+"_"+groupeBr.getName().replace("_grp", "");
                for (int i = 0; i < boutons.size(); i++) {
                        if (boutons.get(i).getId().equals(id)) {
                                boutons.get(i).setValue(true);
                        }
                }
        }
        
        private String creerChaineDenormalisee(List<CheckBox> liste) {
                String identifiants = "";
                int taille = liste.size();
                for (int i = 0; i < taille; i++) {
                        CheckBox cac = liste.get(i);
                        if (cac.isEnabled()) {
                                identifiants = identifiants.concat(";;"+cac.getData("id"));
                        }
                }
                return identifiants.replaceFirst("^;;", "");
        }
        
        /** Méthode simplifiant la création de FormLayout.
         * Chacun des paramètres peut prendre la valeur null pour utiliser la valeur par défaut.
         * 
         * @param labelWidth largeur des labels. 
         * @param labelAlign alignement des labels
         * @param padding padding du layout
         * @return
         */
        private FormLayout creerFormLayout(Integer labelWidth, LabelAlign labelAlign, Integer padding) {
                FormLayout formLayout = new FormLayout();
                if (labelWidth != null) {
                        formLayout.setLabelWidth(labelWidth);
                }
                if (labelAlign != null) {
                        formLayout.setLabelAlign(labelAlign);
                }
                if (padding != null) {
                        formLayout.setPadding(padding);
                }
                return formLayout;
        }
        
        /** Méthode simplifiant la création de bouton radio oui/non
         * 
         * @param listeNom nom de la liste de valeur
         * @return
         */
        private RadioGroup creerChoixUniqueRadioGroupe(String groupeNom, String listeNom) {
                groupeNom += "_grp";
                // NOTE : il semblerait qu'il faille aussi utiliser setName() pour éviter tout problème...
                RadioGroup radioGroup = new RadioGroup(groupeNom);
                radioGroup.setName(groupeNom);

                if (listeNom.equals("ouiNon")) {
                        ValeurListe ouiNonListe = new ValeurListe();
                        ouiNonListe.ajouter(new Valeur("1", "Oui", "NULL", "NULL"));
                        ouiNonListe.ajouter(new Valeur("0", "Non", "NULL", "NULL"));
                        creerChoixUniqueBoutonRadio(radioGroup, ouiNonListe);
                }
                
                return radioGroup;
        }
        
        private void creerChoixUniqueBoutonRadio(RadioGroup radioGroupe, ValeurListe listeValeurs) {
                for (Iterator<String> it = listeValeurs.keySet().iterator(); it.hasNext();) {
                        Valeur val = listeValeurs.get(it.next());
                        
                        Radio radioBtn = new Radio();
                        radioBtn.setName(radioGroupe.getName().replace("_grp", ""));
                        radioBtn.setId(val.getId()+"_"+radioBtn.getName());
                        radioBtn.setBoxLabel(val.getNom());
                        radioBtn.setValueAttribute(val.getId());
                        radioBtn.addListener(Events.Change, new Listener<ComponentEvent>() {
        
                                public void handleEvent(ComponentEvent be) {
                                        //Window.alert(((Radio) be.component).getName());
                                        afficherChampSupplementaire(((Radio) be.component));
                                }
                                
                        });
                        
                        if (! val.getDescription().equals("NULL")) {
                                radioBtn.setToolTip(new ToolTipConfig(val.getNom(), val.getDescription()));
                        }
                        radioGroupe.add(radioBtn);
                }
        } 
        
        private void afficherChampSupplementaire(Radio radioBtn) {
                //GWT.log("Nom btn : "+radioBtn.getName()+" - Nom group : "+radioBtn.getGroup().getName(), null);
                // Valeur du bouton radio déclenchant l'affichage des composants cachés
                String valeurPourAfficher = "oui";
                
                // Construction de la liste des composants à afficher/cacher
                String radioGroupeNom = radioBtn.getGroup().getName();
                ArrayList<Object> composants = new ArrayList<Object>();         
                if (radioGroupeNom.equals("action_mark_grp")) {
                        composants.add(actionTrukCp);
                } else if (radioGroupeNom.equals("future_action_mark_grp")) {
                        composants.add(futureActionChp);
                } else if (radioGroupeNom.equals("sans_motif_acces_mark_grp")) {
                        composants.add(sansMotifAccesChp);
                } else if (radioGroupeNom.equals("avec_motif_acces_mark_grp")) {
                        composants.add(avecMotifAccesChp);
                } else if (radioGroupeNom.equals("recherche_mark_grp")) {
                        composants.add(provenanceRechercheTrukCp);
                        composants.add(typeRechercheTrukCp);
                } else if (radioGroupeNom.equals("formation_mark_grp")) {
                        composants.add(formationChp);
                } else if (radioGroupeNom.equals("collection_commune_mark_grp")) {
                        composants.add(collectionAutreTrukCp);
                } else if (radioGroupeNom.equals("restauration_mark_grp")) {
                        composants.add(opRestauTrukCp);
                } else if (radioGroupeNom.equals("traitement_mark_grp")) {
                        composants.add(traitementTrukCp);
                } else if (radioGroupeNom.equals("echantillon_acquisition_mark_grp")) {
                        composants.add(traitementAcquisitionMarkRGrpChp);
                } else if (radioGroupeNom.equals("traitement_acquisition_mark_grp")) {
                        composants.add(traitementAcquisitionMarkLabel);
                        composants.add(poisonTraitementTrukCp);
                        composants.add(insecteTraitementTrukCp);
                } else if (radioGroupeNom.equals("materiel_conservation_ce_grp")) {
                        composants.add(autreMaterielTrukCp);
                        valeurPourAfficher = "non";
                }
                
                // Nous affichons/cachons les composant de la liste
                final int nbreComposants = composants.size();
                //GWT.log("Id : "+radioBtn.getId()+" - Class : "+radioBtn.getClass().toString()+"- Taille : "+tailleMax, null);
                //Window.alert("Radio grp nom : "+radioGroupeNom+" - Id btn : "+radioBtn.getId()+" - Class : "+radioBtn.getClass().toString()+"- Taille : "+tailleMax);
                for (int i = 0; i < nbreComposants; i++) {
                        // En fonction du type de bouton cliquer, on affiche ou cache les champs
                        String type = radioBtn.getBoxLabel().toLowerCase();
                        //GWT.log(type, null);
                        if (radioBtn.getValue() == true) {
                                if (type.equals(valeurPourAfficher)) {
                                        ((Component) composants.get(i)).show();
                                } else {
                                        ((Component) composants.get(i)).hide();
                                }
                        }
                        // Si on a à faire à un ContentPanel, on l'actualise pour déclencher l'affichage
                        if (composants.get(i) instanceof ContentPanel) {
                                ((ContentPanel) composants.get(i)).layout();
                        }
                }
                
        }
        
        /** Méthode simplifiant la création de choix multiple sous forme de case à cocher.
         * Apelle un service retournant la liste des valeurs représentant les cases à cocher.
         * Ajoute ou pas un champ "Autre".
         * 
         * @param listeNom nom de la liste de valeur
         * @return
         */
        private ContentPanel creerChoixMultipleCp(String listeNom) {
                modele.obtenirListeValeurs(((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeNom));
                ContentPanel cp = new ContentPanel();
                cp.setLayout(creerFormLayout(650, LabelAlign.TOP, 0));
                cp.setHeaderVisible(false);
                return cp;
        }
        
        /** Méthode simplifiant la création de choix multiple sous forme de case à cocher.
         * Apelle un service retournant la liste des valeurs représentant les cases à cocher.
         * Ajoute ou pas un champ "Autre".
         * 
         * @param cp panneau conteant le groupe de case à cocher
         * @param cacGroup le groupe de case à cocher
         * @param listeValeurs la liste de valeurs à transformer en case à cocher
         * @param boolAutreChp booléen indiquant si oui ou non le champ autre doit apparaître 
         * @return
         */
        private void creerChoixMultipleCac(ContentPanel cp, CheckBoxGroup cacGroupe, ValeurListe listeValeurs, Field<String> autreChp) {
                cacGroupe.setAutoWidth(true);
                cacGroupe.setData("liste_id", listeValeurs.getId());
                for (Iterator<String> it = listeValeurs.keySet().iterator(); it.hasNext();) {
                        Valeur val = listeValeurs.get(it.next());
                        String nom =  val.get("nom");
                        CheckBox cac = new CheckBox();
                        cac.setId("val-"+val.getId());
                        cac.setData("id", val.getId());
                        cac.setBoxLabel(nom);
                        if (! val.getDescription().equals("NULL")) {
                                cac.setToolTip(new ToolTipConfig(val.getNom(), val.getDescription()));
                        }
                        cacGroupe.add(cac);
                }
                cp.add(cacGroupe);
                
                if (autreChp != null) {
                        ContentPanel autreCp = new ContentPanel();
                        autreCp.setLayout(creerFormLayout(75, LabelAlign.TOP, 0));
                        autreCp.setHeaderVisible(false);
                        autreChp.setId("autre-"+listeValeurs.getId());
                        autreChp.setFieldLabel("Autre");
                        autreChp.setLabelStyle("font-weight:normal;");
                        autreCp.add(autreChp);
                        cp.add(autreCp);
                }
                
                cp.layout();
        }
        
        public void rafraichir(Object nouvelleDonnees) {
                try {
                        if (nouvelleDonnees instanceof Information) {
                                Information info = (Information) nouvelleDonnees;
                                if (info.getMessages() != null && !info.getMessages().toString().equals("[]")) {
                                        GWT.log(info.getMessages().toString(), null);
                                }
                                if (info.getType().equals("modif_structure")) {
                                        Info.display("Modification d'une institution", info.toString());
                                } else if (info.getType().equals("ajout_structure")) {
                                        Info.display("Ajout d'une Institution", info.toString());
                                } else if (info.getType().equals("selection_structure")) {
                                        Info.display("Modification d'une institution", info.toString());
                                        mode = "MODIF";
                                        GWT.log("Mode du formulaire : "+mode, null);
                                        String titre = i18nC.titreModifFormStructurePanneau();
                                        if (info.getDonnee(0) != null) {
                                                identification = (Structure) info.getDonnee(0);
                                                if (onglets.getSelectedItem().equals(identificationOnglet)) {
                                                        peuplerStructureIdentification();
                                                }
                                                // Composition du titre
                                                titre += " - ID : "+identification.getId();
                                        }
                                        if (info.getDonnee(1) != null) {
                                                conservation = (StructureConservation) info.getDonnee(1);
                                                if (onglets.getSelectedItem().equals(conservationOnglet)) {
                                                        peuplerStructureConservation();
                                                }
                                        }
                                        if (info.getDonnee(2) != null) {
                                                valorisation = (StructureValorisation) info.getDonnee(2);
                                                if (valorisation != null) {
                                                        if (onglets.getSelectedItem().equals(valorisationOnglet)) {
                                                                peuplerStructureValorisation();
                                                        }
                                                }
                                        }
                                        structureFormPanneau.setHeading(titre);
                                } else if (info.getType().equals("liste_structure_a_personne")) {
                                        if (info.getDonnee(0) != null) {
                                                personnel = (StructureAPersonneListe) info.getDonnee(0);
                                                
                                                //GWT.log(personnel.toString(), null);
                                                if (onglets.getSelectedItem().equals(personnelOnglet)) {
                                                        peuplerStructurePersonnel();
                                                }
                                        }
                                }
                        } else if (nouvelleDonnees instanceof ValeurListe) {
                                ValeurListe listeValeurs = (ValeurListe) nouvelleDonnees;
                                
                                List<Valeur> liste = new ArrayList<Valeur>();
                                for (Iterator<String> it = listeValeurs.keySet().iterator(); it.hasNext();) {
                                        liste.add(listeValeurs.get(it.next()));
                                }
                                // Test pour savoir si la liste contient des éléments
                                if (liste.size() > 0) {
                                        Configuration config = (Configuration) Registry.get(RegistreId.CONFIG);
                                        if (listeValeurs.getId().equals(config.getListeId("stpr"))) {
                                                magazinLstpr.removeAll();
                                                magazinLstpr.add(liste);
                                                comboLstpr.setStore(magazinLstpr);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("stpu"))) {
                                                magazinLstpu.removeAll();
                                                magazinLstpu.add(liste);
                                                comboLstpu.setStore(magazinLstpu);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("statut"))) {
                                                magazinLiStatut.removeAll();
                                                magazinLiStatut.add(liste);
                                                comboLiStatut.setStore(magazinLiStatut);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("fonction"))) {
                                                magazinLiFonction.removeAll();
                                                magazinLiFonction.add(liste);
                                                comboLiFonction.setStore(magazinLiFonction);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("pays"))) {
                                                magazinPays.removeAll();
                                                magazinPays.add(liste);
                                                comboPays.setStore(magazinPays);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("localStockage"))) {
                                                localStockageAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(localStockageTrukCp, localStockageTrukCacGrpChp, listeValeurs, localStockageAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("meubleStockage"))) {
                                                meubleStockageAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(meubleStockageTrukCp, meubleStockageTrukCacGrpChp, listeValeurs, meubleStockageAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("parametreStockage"))) {
                                                parametreStockageAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(parametreStockageTrukCp, parametreStockageTrukCacGrpChp, listeValeurs, parametreStockageAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("autreCollection"))) {
                                                if (collectionAutreTrukCp.getItemByItemId("collectionAutreTrukCacGrpChp") == null) {
                                                        collectionAutreTrukCacGrpChp.setId("collectionAutreTrukCacGrpChp");
                                                        collectionAutreAutreChp = new TextField<String>();
                                                        creerChoixMultipleCac(collectionAutreTrukCp, collectionAutreTrukCacGrpChp, listeValeurs, collectionAutreAutreChp);
                                                }
                                                if (autreCollectionTrukCp.getItemByItemId("autreCollectionTrukCacGrpChp") == null) {
                                                        autreCollectionTrukCacGrpChp.setId("autreCollectionTrukCacGrpChp");
                                                        autreCollectionAutreChp = new TextField<String>();
                                                        creerChoixMultipleCac(autreCollectionTrukCp, autreCollectionTrukCacGrpChp, listeValeurs, autreCollectionAutreChp);
                                                }
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("opRestau"))) {
                                                opRestauAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(opRestauTrukCp, opRestauTrukCacGrpChp, listeValeurs, opRestauAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("onep"))) {
                                                creerChoixUniqueBoutonRadio(materielConservationCeRGrpChp, listeValeurs);
                                                materielConservationCp.add(materielConservationCeRGrpChp);
                                                materielConservationCp.layout();
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("autreMateriel"))) {
                                                autreMaterielAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(autreMaterielTrukCp, autreMaterielTrukCacGrpChp, listeValeurs, autreMaterielAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("poisonTraitement"))) {
                                                poisonTraitementAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(poisonTraitementTrukCp, poisonTraitementTrukCacGrpChp, listeValeurs, poisonTraitementAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("insecteTraitement"))) {
                                                if (traitementTrukCp.getItemByItemId("traitementTrukCacGrpChp") == null) {
                                                        traitementTrukCacGrpChp.setId("traitementTrukCacGrpChp");
                                                        traitementAutreChp = new TextField<String>();
                                                        creerChoixMultipleCac(traitementTrukCp, traitementTrukCacGrpChp, listeValeurs, traitementAutreChp);
                                                }
                                                if (insecteTraitementTrukCp.getItemByItemId("insecteTraitementTrukCacGrpChp") == null) {
                                                        insecteTraitementTrukCacGrpChp.setId("insecteTraitementTrukCacGrpChp");
                                                        insecteTraitementAutreChp = new TextField<String>();
                                                        creerChoixMultipleCac(insecteTraitementTrukCp, insecteTraitementTrukCacGrpChp, listeValeurs, insecteTraitementAutreChp);
                                                }
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("actionValorisation"))) {
                                                actionAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(actionTrukCp, actionTrukCacGrpChp, listeValeurs, actionAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("continentEtFr"))) {
                                                provenanceRechercheAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(provenanceRechercheTrukCp, provenanceRechercheTrukCacGrpChp, listeValeurs, provenanceRechercheAutreChp);
                                        }
                                        if (listeValeurs.getId().equals(config.getListeId("typeRecherche"))) {
                                                typeRechercheAutreChp = new TextField<String>();
                                                creerChoixMultipleCac(typeRechercheTrukCp, typeRechercheTrukCacGrpChp, listeValeurs, typeRechercheAutreChp);
                                        }
                                        //GWT.log("La liste #"+listeValeurs.getId()+" a été reçue!", null);
                                } else {
                                        GWT.log("La liste #"+listeValeurs.getId()+" ne contient aucune valeurs!", null);
                                }
                        }
                } catch (Exception e) {
                        GWT.log("rafraichir()", e);
                }
        }
         
}