WebSVN – eFlore/Applications.coel – Diff – /branches/v1.0-syrah/src/org/tela_botanica/client/vues/publication/PublicationForm.java

 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.InfoLogger;
 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.core.XTemplate;
 import com.extjs.gxt.ui.client.event.BaseEvent;
+import com.extjs.gxt.ui.client.event.ButtonEvent;
-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.Events;
+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.ListStore;
+import com.extjs.gxt.ui.client.store.StoreEvent;
 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 PublicationAPersonneListe auteursAjoutes = null;
+	private PersonneListe auteursAjoutes = null;
-	private PublicationAPersonneListe auteursSupprimes = null;
+	private PersonneListe auteursSupprimes = null;
-	private FieldSet auteursFieldset = null;
+	private LayoutContainer auteursFieldset = null;
 	private ComboBox<Projet> projetsCombo = null;
-	private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
-	private LayoutContainer conteneurChamps;
+	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 ComboBox<Structure> 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 ComboBox<Personne> personnesSaisiesComboBox = 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.setLayout(new FlowLayout());
 		genererTitreFormulaire();
 		creerZoneAuteurs();
-		panneauFormulaire.add(auteursFieldset);
+		zoneHaut.add(auteursFieldset);
 		creerZoneGeneralites();
-		panneauFormulaire.add(generalitesFieldset);
+		zoneBas.add(generalitesFieldset);
 		creerZoneEdition();
-		panneauFormulaire.add(editionFieldset);
+		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 "));
+		personnesSaisiesComboBox = 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 ComboBox<Personne> creerComboBoxPersonnesSaisies() {
+		ListStore<Personne> personnesSaisiesStore = new ListStore<Personne>();
+		ComboBox<Personne> comboBox = new ComboBox<Personne>();
+		comboBox.setWidth(400);
+		comboBox.setEmptyText(i18nC.chercherPersonneSaisi());
+		comboBox.setTriggerAction(TriggerAction.ALL);
+		comboBox.setEditable(true);
+		comboBox.setDisplayField("fmt_nom_complet");
+		comboBox.setStore(personnesSaisiesStore);
+		comboBox.addKeyListener(new KeyListener() {
+			public void componentKeyUp(ComponentEvent ce) {
+				if (personnesSaisiesComboBox.getRawValue() != null && personnesSaisiesComboBox.getRawValue().length() > 0) {
+					if (!ce.isNavKeyPress()) {
+						obtenirPersonnesSaisies(personnesSaisiesComboBox.getRawValue());
+					}
+				}
+			}
+		});
+		comboBox.addListener(Events.Select, new Listener<BaseEvent>() {
+			public void handleEvent(BaseEvent be) {
+				if (personnesSaisiesComboBox.getValue() instanceof Personne) {
+					// N'ajouter l'auteur que s'il n'est pas déjà présent dans la grille et dans les valeurs initiales
+					Personne personneSaisieSelectionne = personnesSaisiesComboBox.getValue();
+					if (grille.getStore().findModel(personneSaisieSelectionne) != null)	{
+						Info.display("Information", "La personne est déjà présente dans la liste d'auteurs");
+					} else {
+						if (!auteursInitialListe.containsValue(personneSaisieSelectionne))	{
+							auteursAjoutes.put(personneSaisieSelectionne.getId(), personneSaisieSelectionne);
+						}
+						ajouterDansGrille(personneSaisieSelectionne);
+						personnesSaisiesComboBox.setValue(null);
+					}
+				}
+			}
+		});
+		return comboBox;
+	}
+	private void obtenirPersonnesSaisies(String nom) {
+		mediateur.selectionnerPersonneParNomComplet(this, null, nom+"%");
+	}
+	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() {
-		FormLayout layout = new FormLayout();
-		layout.setLabelWidth(200);
 		// Fieldset Auteur
-		auteursFieldset = new FieldSet();
-		auteursFieldset.setHeading(i18nC.publicationAuteursTitre());
-		auteursFieldset.setCollapsible(true);
-		auteursFieldset.setLayout(layout);
+		auteursFieldset = new LayoutContainer(new FitLayout());
 		auteurComboboxListe = new ArrayList<ComboBox<Personne>>(0);
-		auteursStorePartage = new ListStore<Personne>();
 		mediateur.clicObtenirListeAuteurs(this);
 		creerChampsAuteur();
+	}
 	private void creerChampsAuteur() {
 		auteursFieldset.removeAll();
-		conteneurChamps = new LayoutContainer();
+		barreOutils = creerBarreOutilsGrille();
-		Button ajouterAuteurBouton = new Button(i18nC.publicationAuteurBoutonAjouter());
-		ajouterAuteurBouton.setIcon(Images.ICONES.ajouter());
-		ajouterAuteurBouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
-			public void componentSelected(ButtonEvent be) {
-				creerChampAuteurEtBoutonSupprimer(null);
+		panneauFormulaire.setTopComponent(barreOutils);
-			}
-		});
-		auteursFieldset.add(conteneurChamps);
+		grille = creerGrille();
-		auteursFieldset.add(ajouterAuteurBouton);
+		auteursFieldset.add(grille);
 		auteursFieldset.layout();
+	}
 	public void creerChampAuteurEtBoutonSupprimer(Personne auteur) {
-		final HorizontalPanel panneauHorizontal = new HorizontalPanel();
+		/*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();
+		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);
 		projetsCombo = new ComboBox<Projet>();
 		projetsCombo.setTabIndex(tabIndex++);
 		projetsCombo.setFieldLabel(i18nC.projetChamp());
 		projetsCombo.setDisplayField("nom");
 		projetsCombo.setForceSelection(true);
 		projetsCombo.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("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;
+			}
 		});
 		projetsCombo.setTriggerAction(TriggerAction.ALL);
 		projetsCombo.setStore(new ListStore<Projet>());
 		projetsCombo.addStyleName(ComposantClass.OBLIGATOIRE);
 		projetsCombo.addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
 		generalitesFieldset.add(projetsCombo, new FormData(450, 0));
 		mediateur.selectionnerProjet(this, null);
 		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);
 		ListStore<Structure> editeurStore = new ListStore<Structure>();
 		editeurCombobox = new ComboBox<Structure>();
 		editeurCombobox.setEmptyText("Sélectionner un éditeur...");
 		editeurCombobox.setFieldLabel("Éditeur de la publication");
 		editeurCombobox.setDisplayField("nom");
 		editeurCombobox.setStore(editeurStore);
 		editeurCombobox.setEditable(true);
 		editeurCombobox.setTriggerAction(TriggerAction.ALL);
 		editionFieldset.add(editeurCombobox, new FormData(450, 0));
 		mediateur.clicObtenirListeEditeurs(this);
 		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));
 		tomeChp = new TextField<String>();
 		tomeChp.setFieldLabel("Série de la revue ou tome");
 		editionFieldset.add(tomeChp, new FormData(75, 0));
 		fasciculeChp = new TextField<String>();
 		fasciculeChp.setFieldLabel("Fascicule de la revue");
 		editionFieldset.add(fasciculeChp, new FormData(75, 0));
 		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 StructureListe) {
 			// Si on a reçu une liste des editeurs
 			rafraichirListeEditeurs((StructureListe) nouvellesDonnees);
 		} else if (nouvellesDonnees instanceof PublicationAPersonneListe) {
 			rafraichirListeAuteurs((PublicationAPersonneListe) nouvellesDonnees);
 		} else if (nouvellesDonnees instanceof Information) {
 			rafraichirInformation((Information) nouvellesDonnees);
 		} else if (nouvellesDonnees instanceof ProjetListe) {
 			ProjetListe projets = (ProjetListe) nouvellesDonnees;
 			Formulaire.rafraichirComboBox(projets, projetsCombo);
 			setValeurComboProjets();
 		} 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()).getPersonne();
+			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()).getPersonne();
+			Personne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
 			auteursInitialListe.remove(auteurSupprime.getId());
+		}
+	}
 	private void rafraichirPublication(Publication publi) {
 		publicationOk = true;
 		publication = publi;
+	}
 	private void rafraichirListeEditeurs(StructureListe editeurs) {
 		editeursOk = true;
 		editeurCombobox.getStore().removeAll();
 		editeurCombobox.getStore().add((List<Structure>) editeurs.toList());
+	}
 	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;
-				mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
+			}
+			soumettreAuteurs();
+		}
 		if (info.getType().equals("liste_personne")) {
 			PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
-			List<Personne> liste = listePersonneAuteur.toList();
+			/*List<Personne> liste = listePersonneAuteur.toList();
 			auteursStorePartage.removeAll();
 			auteursStorePartage.add(liste);
+			auteurStorePartageChargementOk = true;*/
+			ListStore store = personnesSaisiesComboBox.getStore();
+			store.removeAll();
+			store.add(listePersonneAuteur.toList());
 			auteurStorePartageChargementOk = true;
 		} 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 && auteursAffiches && editeursOk) {
+		if (mode.equals(Formulaire.MODE_MODIFIER) && publicationOk && editeursOk) {
 			ok = true;
+		}
 		return ok;
+	}
 	private Boolean etreValide() {
 		Boolean valide = false;
-		if (formulaireValideOk && publicationValideOk && auteursValideOk) {
+		if (formulaireValideOk && auteursValideOk) {
 			valide = true;
+		}
 		return valide;
+	}
 	private void initialiserValidation() {
 		formulaireValideOk = false;
 		publicationValideOk = false;
 		initialiserAuteurs();
 		auteursValideOk = false;
+	}
 	private void initialiserAuteurs() {
 		attenteAjoutAuteursOk = true;
-		auteursAjoutes = new PublicationAPersonneListe();
+		auteursAjoutes = new PersonneListe();
 		attenteSuppressionAuteursOk = true;
-		auteursSupprimes = new PublicationAPersonneListe();
+		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();
-			soumettreAuteurs();
+			//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);
-				auteursAjoutes.put(publicationAAuteur.getId(), publicationAAuteur);
+				//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);
-					auteursSupprimes.put(publicationAAuteur.getId(), publicationAAuteur);
+					//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) {
-				mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
+				//FIXME : mediateur.ajouterPublicationAPersonne(this, publication.getId(), auteursAjoutes, PublicationAPersonne.ROLE_AUTEUR);
+			}
 			if (auteursSupprimes != null && auteursSupprimes.size() != 0) {
-				mediateur.supprimerPublicationAPersonne(this, auteursSupprimes);
+				//FIXME : mediateur.supprimerPublicationAPersonne(this, auteursSupprimes);
+			}
-		}
+		}*/
+	}
 	public boolean verifierFormulaire() {
 		boolean valide = true;
 		ArrayList<String> messages = new ArrayList<String>();
-		boolean auteurErreur = true;
-		for (int i = 0; i < auteurComboboxListe.size(); i++) {
+		// Tester si au moins un auteur est présent
-			if (auteurComboboxListe.get(i).getValue() != null) {
-				auteurErreur = false;
-				break;
-			}
-		}
-		if (auteurErreur) {
+		if (grille.getStore().getModels().size() == 0) {
-			messages.add("Veuillez saisir au moins un auteur !");
+			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.setValue(editeurCombobox.getStore().findModel("id_structure", publication.getEditeur()));
 		} else {
 			editeurCombobox.setRawValue(publication.getEditeur());
+		}
+	}
 	private Publication collecterPublication() {
-		Publication publicationCollectee = (Publication) publication.cloner(new Publication());
 		Publication publicationCollectee = (Publication) publication.cloner(new Publication());
-		publicationCollectee.setIdProjet(getValeurComboProjets());
 		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.getValue() != null) {
 			editeur = editeurCombobox.getValue().getId();
 			publicationCollectee.setStructureEditeur(editeurCombobox.getValue());
 		} else if (editeurCombobox.getRawValue() != "") {
 			editeur = editeurCombobox.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.getValue() != null) {
 			editeur = editeurCombobox.getValue().getNom();
 		} else if (editeurCombobox.getRawValue() != "") {
 			editeur = editeurCombobox.getRawValue();
+		}
 		return editeur;
+	}
 	private String construireIntituleAuteur() {
-		String inituleAuteur = "";
+		String intituleAuteur = "";
+		List<Personne> auteurs = grille.getStore().getModels();
+		Iterator<Personne> itAuteurs = auteurs.iterator();
+		while (itAuteurs.hasNext())	{
+			Personne personneCourante = itAuteurs.next();
+			intituleAuteur += personneCourante.getNom().toUpperCase() + " " + personneCourante.getPrenom();
+			if (itAuteurs.hasNext())	{
+				intituleAuteur+=", ";
+			}
+		}
+		/*
-		int auteursNombre = auteurComboboxListe.size();
+		 * 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 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.getValue() != null) {
 			valeur = projetsCombo.getValue().getId();
+		}
 		return valeur;
+	}
 	private void setValeurComboProjets() {
 		if (projetsCombo.getStore() != null ) {
 			if (mode.equals(Formulaire.MODE_MODIFIER) && publication != null) {
 				projetsCombo.setValue(projetsCombo.getStore().findModel("id_projet", publication.getIdProjet()));
 			} else if (mode.equals(Formulaire.MODE_AJOUTER)) {
 				projetsCombo.setValue(projetsCombo.getStore().findModel("id_projet", mediateur.getProjetId()));
+			}
+		}
+	}
+}

Subversion Repositories eFlore/Applications.coel

(root)/branches/v1.0-syrah/src/org/tela_botanica/client/vues/publication/PublicationForm.java – Rev 1255 → 1273