Subversion Repositories eFlore/Applications.coel

Rev

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

package org.tela_botanica.client.vues.publication;

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

import org.tela_botanica.client.ComposantClass;
import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.composants.ChampComboBoxRechercheTempsReelPaginable;
import org.tela_botanica.client.composants.InfoLogger;
import org.tela_botanica.client.composants.pagination.ProxyPersonnes;
import org.tela_botanica.client.composants.pagination.ProxyProjets;
import org.tela_botanica.client.composants.pagination.ProxyStructures;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
import org.tela_botanica.client.modeles.Valeur;
import org.tela_botanica.client.modeles.aDonnee;
import org.tela_botanica.client.modeles.personne.Personne;
import org.tela_botanica.client.modeles.personne.PersonneListe;
import org.tela_botanica.client.modeles.projet.Projet;
import org.tela_botanica.client.modeles.projet.ProjetListe;
import org.tela_botanica.client.modeles.publication.Publication;
import org.tela_botanica.client.modeles.publication.PublicationAPersonne;
import org.tela_botanica.client.modeles.publication.PublicationAPersonneListe;
import org.tela_botanica.client.modeles.structure.Structure;
import org.tela_botanica.client.modeles.structure.StructureListe;
import org.tela_botanica.client.util.Debug;
import org.tela_botanica.client.util.Pattern;
import org.tela_botanica.client.util.UtilArray;
import org.tela_botanica.client.util.UtilString;
import org.tela_botanica.client.vues.FenetreForm;
import org.tela_botanica.client.vues.Formulaire;
import org.tela_botanica.client.vues.FormulaireBarreValidation;
import org.tela_botanica.client.vues.personne.PersonneForm;

import com.extjs.gxt.ui.client.Style.Scroll;
import com.extjs.gxt.ui.client.Style.SortDir;
import com.extjs.gxt.ui.client.core.XTemplate;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.ModelType;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.Store;
import com.extjs.gxt.ui.client.store.StoreEvent;
import com.extjs.gxt.ui.client.widget.ContentPanel;
import com.extjs.gxt.ui.client.widget.HorizontalPanel;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.LayoutContainer;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.button.ButtonBar;
import com.extjs.gxt.ui.client.widget.form.ComboBox;
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.TextField;
import com.extjs.gxt.ui.client.widget.form.Validator;
import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.grid.CellEditor;
import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
import com.extjs.gxt.ui.client.widget.grid.ColumnData;
import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
import com.extjs.gxt.ui.client.widget.grid.Grid;
import com.extjs.gxt.ui.client.widget.grid.GridCellRenderer;
import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
import com.extjs.gxt.ui.client.widget.grid.RowExpander;
import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
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.layout.RowData;
import com.extjs.gxt.ui.client.widget.layout.RowLayout;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;


public class PublicationForm extends Formulaire implements Rafraichissable {
        
        private Publication publication;
        private PersonneListe auteursInitialListe = null;
        private static boolean publicationAPersonneListeChargementOk = false;
        private PersonneListe auteursAjoutes = null;
        private PersonneListe auteursSupprimes = null;
        
        private ContentPanel auteursFieldset = null;
        private ChampComboBoxRechercheTempsReelPaginable projetsCombo = null;
        private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
        private ListStore<Personne> auteursStorePartage = null;
        private static boolean auteurStorePartageChargementOk = false;
        
        private FieldSet generalitesFieldset = null;
        private TextField<String> titreChp = null;
        private TextField<String> collectionChp = null;
        private TextField<String> uriChp = null;
        
        private FieldSet editionFieldset = null;
        private ChampComboBoxRechercheTempsReelPaginable editeurCombobox = null;
        private static boolean editeursOk = false;
        private TextField<String> datePublicationChp = null;
        private TextField<String> tomeChp = null;
        private TextField<String> fasciculeChp = null;
        private TextField<String> pagesChp = null;
        
        boolean auteursAffiches = false;
        private static boolean formulaireValideOk = false;
        private static boolean publicationValideOk = false;
        private static boolean auteursValideOk = false;
        private static boolean publicationOk = false;
        private static boolean attenteAjoutAuteursOk = true;
        private static boolean attenteSuppressionAuteursOk = true;
        
        private LayoutContainer zoneHaut, zoneBas;
        
        private static int idGenere = 1;
        private ToolBar barreOutils = null;
        private EditorGrid<Personne> grille;
        private PersonneListe personnesAjoutees = null;
        private PersonneListe personnesSupprimees = null;
        private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null;
        private ChampComboBoxRechercheTempsReelPaginable recherchePersonnesCombo = null;
        private Button personnesBoutonSupprimer = null;
        private Button personnesBoutonModifier = null;
        private ComboBox<Valeur> typeRelationCombo = null;
        private List<Valeur> roles = null;
        private PersonneListe listePersonne = new PersonneListe();
        
        private FenetreForm fenetreFormulaire = null;
        
        public PublicationForm(Mediateur mediateurCourrant, String publicationId) {
                initialiserPublicationForm(mediateurCourrant, publicationId);
        }

        public PublicationForm(Mediateur mediateurCourrant, String publicationId, Rafraichissable vueARafraichirApresValidation) {
                vueExterneARafraichirApresValidation = vueARafraichirApresValidation;
                initialiserPublicationForm(mediateurCourrant, publicationId);
        }
        
        private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) {
                
                auteursInitialListe = new PersonneListe();
                initialiserValidation();
                initialiserAffichageAuteurs();
                
                publication = new Publication();
                publication.setId(publicationId);
                
                String modeDeCreation = (UtilString.isEmpty(publication.getId()) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
                initialiserFormulaire(mediateurCourrant, modeDeCreation, MenuApplicationId.PUBLICATION);
                panneauFormulaire.setLayout(new RowLayout());
                panneauFormulaire.setStyleAttribute("padding", "0");
                zoneHaut = new LayoutContainer(new FitLayout());
                zoneBas = new LayoutContainer(new FlowLayout());
                
                panneauFormulaire.add(zoneHaut, new RowData(1, 0.3));
                panneauFormulaire.add(zoneBas, new RowData(1, 0.5));
                panneauFormulaire.setScrollMode(Scroll.AUTO);
                genererTitreFormulaire();
                
                creerZoneAuteurs();
                zoneHaut.add(auteursFieldset);
                
                creerZoneGeneralites();
                zoneBas.add(generalitesFieldset);
                
                creerZoneEdition();
                zoneBas.add(editionFieldset);
                
                if (modeDeCreation.equals(Formulaire.MODE_MODIFIER)) {
                        mediateurCourrant.selectionnerPublication(this, publicationId);
                        mediateurCourrant.selectionnerPublicationAPersonne(this, publicationId, null, PublicationAPersonne.ROLE_AUTEUR);
                }
        }
        
        public void actualiserEtatBoutonsBarreOutils() {
                        // Activation des boutons si la grille contient un élément
                        if (grille.getStore().getCount() > 0) {  
                                personnesBoutonSupprimer.enable();
                                personnesBoutonModifier.enable();
                        }
                        // Désactivation des boutons si la grille ne contient plus d'élément
                        if (grille.getStore().getCount() == 0) {  
                                personnesBoutonSupprimer.disable();
                                personnesBoutonModifier.disable();
                        }
                }
        
        private ToolBar creerBarreOutilsGrille() {
                ToolBar barreOutils = new ToolBar();  
                
                Button ajouterBouton = creerBoutonAjouter();
                barreOutils.add(ajouterBouton);
                
                barreOutils.add(new Text(" ou "));
                
                creerComboBoxPersonnesSaisies();
                
                barreOutils.add(personnesSaisiesComboBox);
                
                barreOutils.add(new SeparatorToolItem());
                
                personnesBoutonModifier = creerBoutonModifier();
                barreOutils.add(personnesBoutonModifier);
                
                barreOutils.add(new SeparatorToolItem());
                
                personnesBoutonSupprimer = creerBoutonSupprimer();
                barreOutils.add(personnesBoutonSupprimer);              
                
                barreOutils.add(new SeparatorToolItem());
                
                Button rafraichirBouton = creerBoutonRafraichir();
                barreOutils.add(rafraichirBouton);
                
                return barreOutils;
        }

        private Button creerBoutonAjouter() {
                Button bouton = new Button(i18nC.ajouter());
                bouton.setIcon(Images.ICONES.vcardAjouter());
                bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
                        public void componentSelected(ButtonEvent ce) {  
                                fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_AJOUTER);
                                fenetreFormulaire.show();
                        }  
                });
                return bouton;
        }
        
        private Button creerBoutonModifier() {
                Button bouton = new Button(i18nC.modifier());
                bouton.setIcon(Images.ICONES.vcardModifier());
                bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
                        public void componentSelected(ButtonEvent ce) {  
                                Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
                                
                                if (personneSaisieSelectionnee == null) {
                                        InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
                                } else {
                                        fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
                                        fenetreFormulaire.show();
                                }
                        }  
                });
                return bouton;
        }
        
        private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
                String personneId = null;
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
                        personneId = personneSaisieSelectionnee.getId();
                }
                
                final FenetreForm fenetre = new FenetreForm("");
                final PersonneForm formulaire = creerFormulairePersonne(fenetre, personneId);
                fenetre.add(formulaire);
                return fenetre;
        }
        
        private PersonneForm creerFormulairePersonne(final FenetreForm fenetre, final String personneId) {
                PersonneForm formulairePersonne = new PersonneForm(mediateur, personneId, this);
                FormPanel panneauFormulaire = formulairePersonne.getFormulaire();
                fenetre.setHeading(panneauFormulaire.getHeading());
                panneauFormulaire.setHeaderVisible(false);
                panneauFormulaire.setTopComponent(null);
                
                // FIXME : avec GXT-2.1.0 la redéfinition du bottom component ne marche plus. Nous le cachons et en créeons un dans la fenêtre.
                panneauFormulaire.getBottomComponent().hide();
                SelectionListener<ButtonEvent> ecouteur = creerEcouteurValidationFormulairePersonne(fenetre, formulairePersonne);
                final ButtonBar barreValidation = new FormulaireBarreValidation(ecouteur);
                fenetre.setBottomComponent(barreValidation);
                
                return formulairePersonne;
        }
        
        private SelectionListener<ButtonEvent> creerEcouteurValidationFormulairePersonne(final FenetreForm fenetre, final PersonneForm formulaire) {
                SelectionListener<ButtonEvent> ecouteur = new SelectionListener<ButtonEvent>() {
                        public void componentSelected(ButtonEvent ce) {
                                String code = ((Button) ce.getComponent()).getData("code");
                                if (code.equals(FormulaireBarreValidation.CODE_BOUTON_VALIDER)) {
                                        if (formulaire.soumettreFormulaire()) {
                                                fenetre.hide();
                                        }
                                } else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_APPLIQUER)) {
                                        formulaire.soumettreFormulaire();
                                } else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_ANNULER)) {
                                        fenetre.hide();
                                } else if (code.equals(FormulaireBarreValidation.CODE_BOUTON_REINITIALISER)) {
                                        fenetreFormulaire.hide();
                                        fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(formulaire.mode);
                                        fenetreFormulaire.show();
                                }
                        }
                };
                
                return ecouteur;
        }
        
        private Button creerBoutonSupprimer() {
                Button bouton = new Button(i18nC.supprimer());
                bouton.setIcon(Images.ICONES.vcardSupprimer());
                bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
                        public void componentSelected(ButtonEvent ce) {
                                Personne personneSaisieSelectionnee = grille.getSelectionModel().getSelectedItem();
                                if (personneSaisieSelectionnee == null) {
                                        InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
                                } else {
                                        supprimerDansGrille(personneSaisieSelectionnee);
                                }
                        }   
                });
                return bouton;
        }
        
        private Button creerBoutonRafraichir() {
                Button bouton = new Button(i18nC.rafraichir());
                bouton.setIcon(Images.ICONES.rafraichir());
                bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {  
                        public void componentSelected(ButtonEvent ce) {
                                actualiserGrille();
                        }   
                });
                return bouton;
        }
        
        private void actualiserGrille() {
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        // FIXME : c'est la merde
                        //mediateur.selectionner(this, null, personneSelectionnee.getId(), "%");
                } else {
                        grille.getStore().removeAll();
                        layout();
                }
        }
        
        private void creerComboBoxPersonnesSaisies() {
                
                ModelType modelTypePersonnes = new ModelType();
                modelTypePersonnes.setRoot("personnes");
                modelTypePersonnes.setTotalName("nbElements");
                modelTypePersonnes.addField("cp_fmt_nom_complet");
                modelTypePersonnes.addField("cp_id_personne");
                modelTypePersonnes.addField("cp_code_postal");
                modelTypePersonnes.addField("cp_ville");
                modelTypePersonnes.addField("cp_truk_courriel");
                
                String displayNamePersonnes = "cp_fmt_nom_complet";
                ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>();
                
                personnesSaisiesComboBox = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
                
                personnesSaisiesComboBox.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
                        public void handleEvent(BaseEvent be) {                         
                                if (personnesSaisiesComboBox.getValeur() instanceof ModelData) {
                                        // N'ajouter l'auteur que s'il n'est pas déjà présent dans la grille et dans les valeurs initiales
                                        Personne personneSaisieSelectionnee = new Personne(personnesSaisiesComboBox.getValeur());
                                        if (grille.getStore().findModel(personneSaisieSelectionnee) != null)    {
                                                Info.display("Information", "La personne est déjà présente dans la liste d'auteurs");
                                        } else {
                                                if (!auteursInitialListe.containsValue(personneSaisieSelectionnee))     {
                                                        auteursAjoutes.put(personneSaisieSelectionnee.getId(), personneSaisieSelectionnee);
                                                }
                                                ajouterDansGrille(personneSaisieSelectionnee);
                                                personnesSaisiesComboBox.getCombo().setValue(null);
                                        }
                                }
                        }
                });
        }
        
        private void ajouterDansGrille(Personne personne) {
                ajouterDansGrille(personne, 0);
        }
        
        private void ajouterDansGrille(Personne personne, int index) {
                if (personne != null) {
                        if (!grille.getStore().contains(personne))      {
                                //1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter
                                if (!auteursInitialListe.containsValue(personne))       {
                                        auteursAjoutes.put(personne.getId(), personne);
                                }
                                
                                // L'enlever de la liste à supprimer
                                if (auteursSupprimes.containsValue(personne))   {
                                        auteursSupprimes.remove(personne);
                                }
                                //2) Ajouter a la grille
                                grille.getStore().insert(personne, index);
                                grille.getSelectionModel().select(index, false);
                        } else {
                                InfoLogger.display("Information", "La personne choisie existe déjà dans la liste.");
                        }
                }
        }
        
        /**
         * Met à jour la grille avec les informations contenus dans la variable listePublicationsLiees
         */
        private void mettreAJourGrille()        {

                grille.getStore().removeAll();
                grille.getStore().add(listePersonne.toList());
        }
        
        private void supprimerDansGrille(Personne personne) {
                if (personne != null) {
                        //1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
                        if (auteursInitialListe.containsValue(personne)) {
                                auteursSupprimes.put(personne.getId(), personne);
                        }
                        
                        if (auteursAjoutes.containsValue(personne))     {
                                auteursAjoutes.remove(personne);
                        }
                        
                        //2) Supprimer la personne de la liste
                        grille.getStore().remove(personne);     
                } else {
                        Info.display("Information", "Vous devez sélectionner une personne");
                }
        }
        
        private EditorGrid<Personne> creerGrille() {
                
                ListStore<Personne> storeGrille = new ListStore<Personne>();
                storeGrille.addListener(Store.Add, new Listener<StoreEvent<Personne>>() {
                        public void handleEvent(StoreEvent<Personne> ce) {
                                actualiserEtatBoutonsBarreOutils();
                        }
                });
                
                storeGrille.addListener(Store.Remove, new Listener<StoreEvent<Personne>>() {
                        public void handleEvent(StoreEvent<Personne> ce) {
                                actualiserEtatBoutonsBarreOutils();
                        }
                });
                
                storeGrille.addListener(Store.Update, new Listener<StoreEvent<Personne>>() {
                        public void handleEvent(StoreEvent<Personne> ce) {
                                if (ce.getRecord().isModified("_role_") && !ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
                                        ce.getModel().set("_etat_", aDonnee.ETAT_MODIFIE);
                                }
                        }
                });             
                
                List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
                colonnes.add(new ColumnConfig("fmt_nom_complet", i18nC.personneNomComplet(), 150));
                colonnes.add(new ColumnConfig("code_postal", i18nC.personneCodePostal(), 150));
                colonnes.add(new ColumnConfig("ville", i18nC.personneVille(), 75));
                colonnes.add(new ColumnConfig("truk_courriel", i18nC.personneCourriel(), 75));
                
                GridSelectionModel<Personne> modeleDeSelection = new GridSelectionModel<Personne>();
                
                ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
                
                EditorGrid<Personne> grillePublications = new EditorGrid<Personne>(storeGrille, modeleDeColonnes);
                grillePublications.setHeight("100%");
                grillePublications.setBorders(true);
                grillePublications.setSelectionModel(modeleDeSelection);
                grillePublications.getView().setForceFit(true);
                grillePublications.setAutoExpandColumn("fmt_nom_complet");
                grillePublications.setStripeRows(true);
                grillePublications.setTrackMouseOver(true);
                
                return grillePublications;
        }
        
        private void genererTitreFormulaire() {
                String titre = i18nC.publicationTitreFormAjout();
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                         titre = i18nC.publicationTitreFormModif();
                         if (publication != null) {
                                 titre += " - "+i18nC.id()+": "+publication.getId()+" - "+publication.getObjetDeLaPublication();
                         }
                }
                panneauFormulaire.setHeading(titre);
        }

        private void creerZoneAuteurs() {
                auteursFieldset = new ContentPanel();
                auteursFieldset.setLayout(new FitLayout());
                auteursFieldset.setHeading("Auteurs");
                
                auteurComboboxListe = new ArrayList<ComboBox<Personne>>(0);
                mediateur.clicObtenirListeAuteurs(this);
                
                creerChampsAuteur();
        }
        
        private void creerChampsAuteur() {
                auteursFieldset.removeAll();
                barreOutils = creerBarreOutilsGrille();
                auteursFieldset.setTopComponent(barreOutils);
                grille = creerGrille();
                auteursFieldset.add(grille);
                auteursFieldset.layout();
        }
        
        public void creerChampAuteurEtBoutonSupprimer(Personne auteur) {
                /*final HorizontalPanel panneauHorizontal = new HorizontalPanel();

                LayoutContainer panneauChampTxt = new LayoutContainer();
                panneauChampTxt.setLayout(new FormLayout());

                final ComboBox<Personne> auteursSaisisComboBox = creerComboBoxAuteursSaisis();
                if (auteur != null) {
                        auteursSaisisComboBox.setValue(auteur);
                        auteursSaisisComboBox.validate();
                }
                auteurComboboxListe.add(auteursSaisisComboBox);
                auteursSaisisComboBox.setFieldLabel(i18nC.publicationAuteurSingulier()+" "+auteurComboboxListe.size());
                panneauChampTxt.add(auteursSaisisComboBox, new FormData(300, 0));
                panneauHorizontal.add(panneauChampTxt);
                
                Button supprimerAuteurBouton = new Button();
                supprimerAuteurBouton.setIcon(Images.ICONES.supprimer());
                supprimerAuteurBouton.setToolTip(i18nC.supprimer());
                supprimerAuteurBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        @Override
                        public void componentSelected(ButtonEvent be) {
                                auteurComboboxListe.remove(auteursSaisisComboBox);
                                conteneurChamps.remove(panneauHorizontal);
                                
                                int numeroAuteurs = 1;
                                for (Iterator<ComboBox<Personne>> it = auteurComboboxListe.iterator(); it.hasNext();) {
                                        it.next().setFieldLabel(i18nC.publicationAuteurSingulier()+" "+numeroAuteurs);
                                        numeroAuteurs++;
                                }

                                auteursFieldset.layout();
                        }
                });
                panneauHorizontal.add(supprimerAuteurBouton);

                conteneurChamps.add(panneauHorizontal);
                auteursFieldset.layout();*/
        }
        
        /*
        private ComboBox<Personne> creerComboBoxAuteursSaisis() {
                ListStore<Personne> auteursStore = new ListStore<Personne>();
                auteursStore.add(auteursStorePartage.getModels());
                
                ComboBox<Personne> comboBox = new ComboBox<Personne>();
                comboBox.setEmptyText(i18nC.chercherPersonneSaisi());
                comboBox.setEditable(true);
                comboBox.setAllowBlank(false);
                comboBox.setForceSelection(true);
                comboBox.setDisplayField("fmt_nom_complet");
                comboBox.setTriggerAction(TriggerAction.ALL);
                comboBox.setStore(auteursStore);
                comboBox.setMessageTarget("tooltip");
                comboBox.addStyleName(ComposantClass.OBLIGATOIRE);
                comboBox.addListener(Events.Valid, creerEcouteurChampObligatoire());

                return comboBox;
        }*/
        
        private void creerZoneGeneralites() {
                FormLayout layout = new FormLayout();
                layout.setLabelWidth(200);
                
                // Fieldset Infos Générales
                generalitesFieldset = new FieldSet();
                generalitesFieldset.setHeading("Informations générales");
                generalitesFieldset.setCollapsible(true);
                generalitesFieldset.setLayout(layout);

                
                ModelType modelTypeProjets = new ModelType();
                modelTypeProjets.setRoot("projets");
                modelTypeProjets.setTotalName("nbElements");
                modelTypeProjets.addField("cpr_nom");
                modelTypeProjets.addField("cpr_id_projet");
                
                String displayNameProjets = "cpr_nom";
                ProxyProjets<ModelData> proxyProjets = new ProxyProjets<ModelData>();
                
                projetsCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyProjets, modelTypeProjets, displayNameProjets);
                projetsCombo.setWidth(200, 600);
                projetsCombo.getCombo().setTabIndex(tabIndex++);
                projetsCombo.getCombo().setFieldLabel(i18nC.projetChamp());
                projetsCombo.getCombo().setForceSelection(true);
                projetsCombo.getCombo().addStyleName(ComposantClass.OBLIGATOIRE);
                projetsCombo.getCombo().addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
                
                projetsCombo.getCombo().setValidator(new Validator() {
                        public String validate(Field<?> field, String value) {
                                String retour = null;
                                if (field.getRawValue().equals("")) {
                                        field.setValue(null);
                                } else if (projetsCombo.getStore().findModel("cpr_nom", field.getRawValue()) == null) {
                                        String contenuBrut = field.getRawValue();
                                        field.setValue(null);
                                        field.setRawValue(contenuBrut);
                                        retour = "Veuillez sélectionner une valeur ou laisser le champ vide";
                                }
                                return retour;
                        }
                });     
                generalitesFieldset.add(projetsCombo, new FormData(600, 0));
                
                titreChp = new TextField<String>();
                titreChp.setName("cpu");
                titreChp.setFieldLabel("Titre de l'article ou de l'ouvrage");
                titreChp.addStyleName(ComposantClass.OBLIGATOIRE);
                titreChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
                generalitesFieldset.add(titreChp, new FormData(450, 0));
                
                collectionChp = new TextField<String>();
                collectionChp.setFieldLabel("Intitulé de la revue ou de la collection");
                generalitesFieldset.add(collectionChp, new FormData(450, 0));
                
                uriChp = new TextField<String>();
                uriChp.setFieldLabel("URL de la publication");
                generalitesFieldset.add(uriChp, new FormData(450, 0));
        }
        
        private void creerZoneEdition() {
                FormLayout layout = new FormLayout();
                layout.setLabelWidth(200);

                // Fieldset Edition
                editionFieldset = new FieldSet();
                editionFieldset.setHeading("Édition");
                editionFieldset.setCollapsible(true);
                editionFieldset.setLayout(layout);

                /*****************************************************/
                /**                     Champ 'Editeur de la publication'               **/
                /*****************************************************/         
                ModelType modelTypeStructures = new ModelType();
                modelTypeStructures.setRoot("structures");
                modelTypeStructures.setTotalName("nbElements");
                modelTypeStructures.addField("cs_nom");
                modelTypeStructures.addField("cs_id_structure");
                
                String displayNameStructures = "cs_nom";
                ProxyStructures<ModelData> proxyStructures = new ProxyStructures<ModelData>();
                
                editeurCombobox = new ChampComboBoxRechercheTempsReelPaginable(proxyStructures, modelTypeStructures, displayNameStructures);
                editeurCombobox.setWidth(200, 600);
                editeurCombobox.getCombo().setTabIndex(tabIndex++);
                editeurCombobox.getCombo().setEmptyText("Sélectionner un éditeur...");
                editeurCombobox.getCombo().setFieldLabel("Éditeur de la publication");
                editeurCombobox.getCombo().setEditable(true);
                editionFieldset.add(editeurCombobox, new FormData(600, 0));
                
                /*********************************************/
                /**                     Champ 'Date de publication'             **/
                /*********************************************/                 
                datePublicationChp = new TextField<String>();
                datePublicationChp.setMaxLength(4);
                datePublicationChp.setMinLength(4);
                datePublicationChp.setFieldLabel("Année de publication");
                datePublicationChp.addStyleName(ComposantClass.OBLIGATOIRE);
                datePublicationChp.addListener(Events.Valid, creerEcouteurChampObligatoire());
                editionFieldset.add(datePublicationChp, new FormData(40, 0));
                
                /*****************************/
                /**                     Champ ''                **/
                /*****************************/ 
                tomeChp = new TextField<String>();
                tomeChp.setFieldLabel("Série de la revue ou tome");
                editionFieldset.add(tomeChp, new FormData(75, 0));

                /*****************************/
                /**                     Champ ''                **/
                /*****************************/ 
                fasciculeChp = new TextField<String>();
                fasciculeChp.setFieldLabel("Fascicule de la revue");
                editionFieldset.add(fasciculeChp, new FormData(75, 0));

                /*****************************/
                /**                     Champ ''                **/
                /*****************************/ 
                pagesChp = new TextField<String>();
                pagesChp.setFieldLabel("Pages");
                pagesChp.setToolTip("Fomat : NBRE ou NBRE-NBRE. ('NBRE' correspond à une suite de chiffres arabes ou romains ou à un point d'interrogation '?' dans le cas d'une donnée inconnue)");
                editionFieldset.add(pagesChp, new FormData(100, 0));
        }

        public void rafraichir(Object nouvellesDonnees) {
                if (nouvellesDonnees instanceof Publication) {
                        // Si on a reçu les details d'une publication
                        rafraichirPublication((Publication) nouvellesDonnees);
                } else if (nouvellesDonnees instanceof PublicationAPersonneListe) {
                        rafraichirListeAuteurs((PublicationAPersonneListe) nouvellesDonnees);
                } else if (nouvellesDonnees instanceof Information) {
                        rafraichirInformation((Information) nouvellesDonnees);  
                } else {
                        GWT.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()), null);
                }
                
                synchronisation();
        }
        
        private void synchronisation() {
                // Respecter l'ordre et faire attention à la réinitialisation des jetons
                // 1. gestion des auteurs (Modif ou Ajout)
                // 2. peupler le formulaire (Modif)
                // 3. initialisation de la gestion des auteurs ajoutés/supprimés (Modif)
                // 4. valider le formulaire (Modif ou Ajout)
                
                if (etrePretAAfficherAuteurs()) {
                        afficherAuteurs();
                        initialiserAffichageAuteurs();
                }
                
                if (etrePretAPeupler()) {                       
                        peuplerFormulaire();
                        genererTitreFormulaire();
                        initialiserPeupler();
                }
                
                if (avoirAuteursMiseAJourCorrectement()) {
                        miseAJourAuteursInitialListe();
                        initialiserAuteurs();
                        auteursValideOk = true;
                }
                
                if (etreValide()) {
                        initialiserValidation();
                        repandreRafraichissement();
                        controlerFermeture();
                }
        }
        
        private void miseAJourAuteursInitialListe() {
                Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
                while (clesAjoutees.hasNext()) {
                        Personne auteurAjoute = auteursAjoutes.get(clesAjoutees.next());
                        auteursInitialListe.put(auteurAjoute.getId(), auteurAjoute);
                }
                
                Iterator<String> clesSupprimees = auteursSupprimes.keySet().iterator();
                while (clesSupprimees.hasNext()) {
                        Personne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
                        auteursInitialListe.remove(auteurSupprime.getId());
                }
        }
        
        private void rafraichirPublication(Publication publi) {
                publicationOk = true;
                publication = publi;
        }
        
        private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
                Iterator<String> it = auteurs.keySet().iterator();
                while (it.hasNext()) {
                        Personne auteur = auteurs.get(it.next()).getPersonne();                 
                        auteursInitialListe.put(auteur.getId(), auteur);
                }
                
                grille.getStore().removeAll();
                grille.getStore().add(auteursInitialListe.toList());
                
                publicationAPersonneListeChargementOk = true;
        }
        
        private void rafraichirInformation(Information info) {          
                String type = info.getType();
                if (type.equals("ajout_publication") || type.equals("modif_publication")) {
                        // On vient de soumettre le formulaire, on doit passer à l'étape suivante:
                        // Validation des auteurs ou fermeture du formulaire
                        publicationValideOk = true;
                        if (mode.equals(Formulaire.MODE_AJOUTER)) {
                                if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
                                        String publicationId = (String) info.getDonnee(0);
                                        if (publicationId.matches("[0-9]+")) {
                                                publication.setId(publicationId);
                                        }
                                }
                                attenteAjoutAuteursOk = true;           
                        }
                        soumettreAuteurs();
                }
                
                
                if (info.getType().equals("liste_personne")) {
                        PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
                        
                        /*List<Personne> liste = listePersonneAuteur.toList();
                        auteursStorePartage.removeAll();
                        auteursStorePartage.add(liste);
                        auteurStorePartageChargementOk = true;*/
                        
                        ListStore store = personnesSaisiesComboBox.getStore();
                        store.removeAll();
                        store.add(listePersonneAuteur.toList());
                
                } else if (info.getType().equals("ajout_publication_a_personne")) {
                        attenteAjoutAuteursOk = false;
                } else if (info.getType().equals("suppression_publication_a_personne")) {
                        attenteSuppressionAuteursOk = false;
                } else if (info.getType().equals("modif_publication")) {
                        InfoLogger.display("Modification d'une publication", info.toString());
                } else if (info.getType().equals("ajout_publication")) {
                        if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String && ((String) info.getDonnee(0)).matches("[0-9]+")) {
                                String publicationId = (String) info.getDonnee(0);
                                InfoLogger.display("Ajout d'une publication", "La publication '"+publicationId+"' a bien été ajoutée");
                        } else {
                                InfoLogger.display("Ajout d'une publication", info.toString());
                        }
                }       
        }
        
        private boolean avoirAuteursMiseAJourCorrectement() {
                
                boolean ok = false;
                if (attenteAjoutAuteursOk == false && attenteSuppressionAuteursOk == false) {
                        ok = true;
                }
                return ok;
        }
        
        private void afficherAuteurs() {
                if (mode.equals(Formulaire.MODE_AJOUTER)) {
                        creerChampAuteurEtBoutonSupprimer(null);
                } else if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        Iterator<String> itap = auteursInitialListe.keySet().iterator();
                        while (itap.hasNext()) {
                                creerChampAuteurEtBoutonSupprimer(auteursInitialListe.get(itap.next()));
                        }
                }
                auteursAffiches = true;
        }

        private void initialiserAffichageAuteurs() {
                auteurStorePartageChargementOk = false;
                publicationAPersonneListeChargementOk = false;
        }
        
        private void initialiserPeupler() {
                publicationOk = false;
                editeursOk = false;
                auteursAffiches = false;
        }

        private boolean etrePretAAfficherAuteurs() {
                boolean ok = false;
                if (auteurStorePartageChargementOk 
                                && ((mode.equals(Formulaire.MODE_MODIFIER) && publicationOk && publicationAPersonneListeChargementOk) 
                                                || (mode.equals(Formulaire.MODE_AJOUTER)))) {
                        ok = true;
                }
                return ok;
        }
        
        private boolean etrePretAPeupler() {
                boolean ok = false;
                if (mode.equals(Formulaire.MODE_MODIFIER) && publicationOk && editeursOk) {
                        ok = true;
                }
                return ok;
        }
        
        private Boolean etreValide() {
                Boolean valide = false;
                if (formulaireValideOk && auteursValideOk) {
                        valide = true;
                }
                return valide;
        }
        
        private void initialiserValidation() {
                formulaireValideOk = false;
                publicationValideOk = false;
                initialiserAuteurs();
                auteursValideOk = false;
        }
        
        private void initialiserAuteurs() {
                attenteAjoutAuteursOk = true;
                auteursAjoutes = new PersonneListe();
                attenteSuppressionAuteursOk = true;
                auteursSupprimes = new PersonneListe();
        }
        
        private void repandreRafraichissement() {
                if (vueExterneARafraichirApresValidation != null) {
                        String type = "publication_modifiee";
                        if (mode.equals(Formulaire.MODE_AJOUTER)) {
                                type = "publication_ajoutee";
                        }
                        Information info = new Information(type);
                        info.setDonnee(0, publication);
                        vueExterneARafraichirApresValidation.rafraichir(info);
                }
        }
        
        public boolean soumettreFormulaire() {
                formulaireValideOk = verifierFormulaire();
                if (formulaireValideOk) {
                        soumettrePublication();
                        //Les auteurs seront mis à jour lors du rafraichissement
                }
                return formulaireValideOk;
        }
        
        private void soumettrePublication() {
                Publication publicationCollectee = collecterPublication();
                if (publicationCollectee != null) {
                        if (mode.equals(Formulaire.MODE_AJOUTER)) {
                                mediateur.ajouterPublication(this, publicationCollectee);
                        } else if (mode.equals(Formulaire.MODE_MODIFIER)) {
                                mediateur.modifierPublication(this, publicationCollectee);
                        }
                }
        }
        
        private void soumettreAuteurs() {
                attenteAjoutAuteursOk = false;
                attenteSuppressionAuteursOk = false;
                
                //1) Auteurs ajoutés : 
                // - Créer une PublicationAAuteurListe
                PublicationAPersonneListe listeDesAuteurs = new PublicationAPersonneListe();
                Iterator<String> itAuteur = auteursAjoutes.keySet().iterator();
                while (itAuteur.hasNext())      {
                        PublicationAPersonne publiAPersonne = new PublicationAPersonne();
                        String cle = itAuteur.next();
                        publiAPersonne.setIdPersonne(cle);
                        publiAPersonne.setIdPublication(publication.getId());
                        listeDesAuteurs.put(cle, publiAPersonne);
                }
                
                // - envoyer au mediateur SSI personnes à ajouter
                if (listeDesAuteurs.size() > 0) {
                        mediateur.ajouterPublicationAPersonne(this, publication.getId(), listeDesAuteurs, PublicationAPersonne.ROLE_AUTEUR);
                        attenteAjoutAuteursOk = true;
                }
                
                //2) Auteurs supprimés : 
                // - Créer une PublicationAPersonneListe
                listeDesAuteurs = new PublicationAPersonneListe();
                itAuteur = auteursSupprimes.keySet().iterator();
                while (itAuteur.hasNext())      {
                        PublicationAPersonne publiAPersonne = new PublicationAPersonne();
                        String cle = itAuteur.next();
                        publiAPersonne.setIdPersonne(cle);
                        publiAPersonne.setIdPublication(publication.getId());
                        listeDesAuteurs.put(cle, publiAPersonne);
                }
                
                // - Envoyer au médiateur SSI personnes à supprimer
                if (listeDesAuteurs.size() > 0) {
                        mediateur.supprimerPublicationAPersonne(this, listeDesAuteurs);
                        attenteSuppressionAuteursOk = true;
                }
                
                /*
                attenteAjoutAuteursOk = false;
                attenteSuppressionAuteursOk = false;
                
                PersonneListe personnesInitiales = auteursInitialListe;
                
                PersonneListe personnesActuelles = new PersonneListe();
                if (auteurComboboxListe != null) {
                        Iterator<ComboBox<Personne>> itcp = auteurComboboxListe.iterator();
                        while (itcp.hasNext()) {
                                ComboBox<Personne> combobox = itcp.next();
                                Personne personne = combobox.getValue();
                                if (personne != null) {
                                        personnesActuelles.put(personne.getId(), personne);
                                } else {
                                        Debug.log("Etre valide :"+combobox.isValid()+" - "+combobox.getRawValue());
                                }
                        }
                }
                
                // Auteurs ajoutés
                Iterator<String> clesActuelles = personnesActuelles.keySet().iterator();
                while (clesActuelles.hasNext()) {
                        String idActuel = clesActuelles.next();
                        if (personnesInitiales.size() == 0 || personnesInitiales.get(idActuel) == null) {
                                Personne personne = personnesActuelles.get(idActuel);
                                PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
                                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                                        publicationAAuteur.setIdPublication(publication.getId());
                                }
                                publicationAAuteur.setPersonne(personne);
                                publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
                                //FIXME : auteursAjoutes.put(publicationAAuteur.getId(), publicationAAuteur);
                                attenteAjoutAuteursOk = true;
                        }
                }

                // Auteurs supprimés
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        Iterator<String> clesInitiales = personnesInitiales.keySet().iterator();
                        while (clesInitiales.hasNext()) {
                                String idInitial = clesInitiales.next();
                                if (personnesActuelles.size() == 0 || personnesActuelles.get(idInitial) == null) {
                                        Personne personne = personnesInitiales.get(idInitial);
                                        PublicationAPersonne publicationAAuteur = new PublicationAPersonne();
                                        publicationAAuteur.setIdPublication(publication.getId());
                                        publicationAAuteur.setPersonne(personne);
                                        publicationAAuteur.setIdRole(PublicationAPersonne.ROLE_AUTEUR);
                                        //FIXME : auteursSupprimes.put(publicationAAuteur.getId(), publicationAAuteur);
                                        attenteSuppressionAuteursOk = true;
                                }
                        }
                }
                
                // Execution de les mise à jour pour le mode MODIFICATION
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        if (auteursAjoutes != null && auteursAjoutes.size() != 0) {
                                //FIXME : mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
                        }
                        
                        if (auteursSupprimes != null && auteursSupprimes.size() != 0) {
                                //FIXME : mediateur.supprimerPublicationAPersonne(this, auteursSupprimes);
                        }
                }*/
        }
        
        public boolean verifierFormulaire() {
                boolean valide = true;
                ArrayList<String> messages = new ArrayList<String>();
                
                // Tester si au moins un auteur est présent
                if (grille.getStore().getModels().size() == 0) {
                        messages.add("Veuillez saisir au moins un auteur.");
                }
                
                String titre = titreChp.getValue();
                if (titre == null || titre.equals("")) {
                        messages.add("Veuillez saisir le titre de la publication !");
                }
                
                String uri = uriChp.getValue();
                if (uri != null && ! uri.isEmpty() && ! uri.matches(Pattern.url)) {
                        messages.add("L'URL saisie n'est pas valide !");
                }
                
                String datePublication = datePublicationChp.getRawValue();
                if (datePublication == null || datePublication.equals("")) {
                        messages.add("Veuillez saisir une année de parution !");
                } else {
                        if (!etreDateValide(datePublication)) {
                                messages.add("Le format de l'année saisie est incorrect !");
                        }
                }
                
                String pages = pagesChp.getValue();
                String valeurPage = "(?:[0-9]+|[IVXLCDM]+|\\?)";
                if (pages != null && ! pages.matches("^(?:"+valeurPage+"|"+valeurPage+"-"+valeurPage+")$")) {
                        messages.add("Le format des pages est incorrect !");
                }
                
                if (messages.size() != 0) {
                        String[] tableauDeMessages = {};
                        tableauDeMessages = messages.toArray(tableauDeMessages);
                        MessageBox.alert("Erreurs de saisies", UtilArray.implode(tableauDeMessages, "<br />"), null);
                        valide = false;
                }
                return valide;          
        }
        
        private void peuplerFormulaire() {
                setValeurComboProjets();
                titreChp.setValue(publication.getTitre());
                collectionChp.setValue(publication.getCollection());
                uriChp.setValue(publication.getURI());
                datePublicationChp.setValue(reduireDateParAnnee(publication.getDateParution()));
                tomeChp.setValue(publication.getIndicationNvt());
                fasciculeChp.setValue(publication.getFascicule());
                pagesChp.setValue(publication.getPages());
                
                if (publication.getEditeur().matches("^[0-9]+$")) {
                        editeurCombobox.getCombo().setValue(editeurCombobox.getStore().findModel("cs_id_structure", publication.getEditeur()));
                } else {
                        editeurCombobox.getCombo().setRawValue(publication.getEditeur());
                }
        }
        
        private Publication collecterPublication() {
                
                Publication publicationCollectee = (Publication) publication.cloner(new Publication());
                publicationCollectee.setIdProjet(getValeurComboProjets());
                publicationCollectee.setAuteur(construireIntituleAuteur());
                
                String titre = titreChp.getValue();
                publicationCollectee.setTitre(titre);
                
                String collection = collectionChp.getValue();
                publicationCollectee.setCollection(collection);
                
                publicationCollectee.setNomComplet(construireNomComplet());
                
                String uri = uriChp.getValue();
                publicationCollectee.setUri(uri);
                
                String editeur = "";
                if (editeurCombobox.getValeur() != null) {
                        Structure structure = new Structure(editeurCombobox.getValeur());
                        editeur = structure.getId();
                        publicationCollectee.setStructureEditeur(structure);
                } else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
                        editeur = editeurCombobox.getCombo().getRawValue();
                }
                publicationCollectee.setEditeur(editeur);
                
                String anneePublication = datePublicationChp.getRawValue();
                String datePublication = anneePublication+"-00-00";
                publicationCollectee.setDateParution(datePublication);
                
                String tome = tomeChp.getValue();
                publicationCollectee.setIndicationNvt(tome);
                
                String fascicule = fasciculeChp.getValue();
                publicationCollectee.setFascicule(fascicule);
                
                String pages = pagesChp.getValue();
                publicationCollectee.setPages(pages);
                
                Publication publicationARetourner = null;
                if (!publicationCollectee.comparer(publication)) {
                        publicationARetourner = publication = publicationCollectee;
                }
                return publicationARetourner;
        }
        
        private String construireIntituleEditeur() {
                String editeur = "";
                if (editeurCombobox.getValeur() != null) {
                        Structure structure = new Structure(editeurCombobox.getValeur());
                        editeur = structure.getNom();
                } else if (!UtilString.isEmpty(editeurCombobox.getCombo().getRawValue())) {
                        editeur = editeurCombobox.getCombo().getRawValue();
                }
                return editeur;
        }
        
        private String construireIntituleAuteur() {
                String intituleAuteur = "";
                
                // TODO : ranger par ordre non-alphabétique
                grille.getStore().sort("nom", SortDir.ASC);
                List<Personne> auteurs = grille.getStore().getModels();
                
                Iterator<Personne> itAuteurs = auteurs.iterator();
                while (itAuteurs.hasNext())     {
                        Personne personneCourante = itAuteurs.next();
                        intituleAuteur += personneCourante.getNomComplet();
                        if (itAuteurs.hasNext())        {
                                intituleAuteur+=", ";
                        }
                } 
                /*
                 * TO DELETE:int auteursNombre = auteurComboboxListe.size();
                 *
                for (int i = 0; i < auteursNombre; i++) {
                        if (auteurComboboxListe.get(i).getValue() != null) {
                                Personne auteur = auteurComboboxListe.get(i).getValue();
                                inituleAuteur += auteur.getNom().toUpperCase()+ " "+auteur.getPrenom();
                                if (i != (auteursNombre - 1)) {
                                        inituleAuteur += ", ";
                                }
                        }
                }*/
                return intituleAuteur;
        }
        
        private String construireNomComplet() {
                // Intitulé de la publication complet : fmt_auteur, date_parution(année). titre. Editeur (nom), collection, fascicule, indication_nvt. pages.
                String nomComplet = "";
                String auteurs = construireIntituleAuteur();
                String annee = datePublicationChp.getRawValue();
                String titre = titreChp.getValue();
                String editeur = construireIntituleEditeur();
                
                nomComplet += auteurs+", "+annee+". "+titre+".";
                
                if (!UtilString.isEmpty(editeur)) {
                        nomComplet += " Éditeur "+editeur+".";
                }
                
                if (collectionChp.getValue() != null) {
                        String revue = collectionChp.getValue();
                        nomComplet += ", "+revue;
                }
                
                if (fasciculeChp.getValue() != null) {
                        String fascicule = fasciculeChp.getValue();
                        nomComplet += ", "+fascicule;
                }
                
                if (tomeChp.getValue() != null) {
                        String tomaison = tomeChp.getValue();
                        nomComplet += ", "+tomaison;
                }
                
                if (collectionChp.getValue() != null || fasciculeChp.getValue() != null || tomeChp.getValue() != null) {
                        nomComplet += ".";      
                }
                
                if (pagesChp.getValue() != null) {
                        String pages = pagesChp.getValue();
                        nomComplet += pages+".";
                }
                
                return nomComplet;
        }
        
        public void reinitialiserFormulaire() {
                if (mode.equals(Formulaire.MODE_MODIFIER)) {
                        mediateur.afficherFormPublication(publication.getId());
                } else {
                        mediateur.afficherFormPublication(null);
                }
        }
        
        private boolean etreDateValide(String anneePublication) {
                boolean valide = true;
                if (!anneePublication.matches("^[0-2][0-9]{3}$")) {
                        valide = false;
                }
                return valide;
        }
        
        private String reduireDateParAnnee(String datePar) {
                if (datePar.matches("^[0-2][0-9]{3}(-[0-9]{2}){2}$")) {
                        return datePar.split("-")[0];
                } else {
                        return "";
                }
        }
        
        private String getValeurComboProjets() {
                String valeur = "";
                if (projetsCombo.getValeur() != null) {
                        Projet projet = new Projet(projetsCombo.getValeur());
                        valeur = projet.getId();
                }
                return valeur;
        }
        private void setValeurComboProjets() {
                if (projetsCombo.getStore() != null ) {
                        if (mode.equals(Formulaire.MODE_MODIFIER) && publication != null) {
                                projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", publication.getIdProjet()));
                        } else if (mode.equals(Formulaire.MODE_AJOUTER)) {
                                projetsCombo.getCombo().setValue(projetsCombo.getStore().findModel("cpr_id_projet", mediateur.getProjetId()));
                        }
                }
        }
}