WebSVN – eFlore/Applications.coel – Diff – /trunk/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.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.collection.CollectionAPersonne;
 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.synchronisation.Sequenceur;
 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.SelectionChangedEvent;
+import com.extjs.gxt.ui.client.event.SelectionChangedListener;
 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;
 public class PublicationForm extends Formulaire implements Rafraichissable {
+	  //-------------//
+	 //  ATTRIBUTS	//
+	//-------------//
-	//Variables de classe:
+	/** Publication **/
-	// Relatives à la publication
+	// on se sert d'un objet Publication lorsque l'on est en mode MODIFIER
+	private Publication publication;
+	// on se sert de l'identifiant d'une publication lorsque l'on est en mode AJOUTER
-	private Publication publication;
+	private String publicationId = null;
-	// Relatives aux auteurs
+	/** Auteurs **/
-	private PersonneListe auteursInitialListe = null;
+	private PublicationAPersonneListe auteursInitialListe = null;
+	private PublicationAPersonneListe auteursAjoutes = null;
-	private PersonneListe auteursAjoutes = null;
+	private PublicationAPersonneListe auteursSupprimes = null;
-	private PersonneListe auteursSupprimes = null;
+	private PublicationAPersonneListe auteursModifies = null;
 	private ContentPanel auteursFieldset = null;
 	private ChampComboBoxRechercheTempsReelPaginable projetsCombo = null;
-	private ArrayList<ComboBox<Personne>> auteurComboboxListe = null;
-	private ListStore<Personne> auteursStorePartage = null;
 	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 TextField<String> datePublicationChp = null;
 	private TextField<String> tomeChp = null;
 	private TextField<String> fasciculeChp = null;
 	private TextField<String> pagesChp = null;
 	private LayoutContainer zoneHaut, zoneBas;
 	private ToolBar barreOutils = null;
-	private EditorGrid<Personne> grille;
+	private EditorGrid<PublicationAPersonne> grilleAuteurs;
 	private ChampComboBoxRechercheTempsReelPaginable personnesSaisiesComboBox = null;
 	private Button personnesBoutonSupprimer = null;
 	private Button personnesBoutonModifier = null;
+	private Button boutonAuteurUp = null;
-	private PersonneListe listePersonne = new PersonneListe();
+	private Button boutonAuteurDown = null;
 	private FenetreForm fenetreFormulaire = null;
 	private Sequenceur sequenceur;
+	private String modeDeCreation = null;
+	boolean changeOrderMarker = false;
+	 //----------------------//
+	//    Constructeurs     //------------------------------------------------------------
 	public PublicationForm(Mediateur mediateurCourrant, String publicationId) {
 		initialiserPublicationForm(mediateurCourrant, publicationId);
+	}
 	public PublicationForm(Mediateur mediateurCourrant, String publicationId, Rafraichissable vueARafraichirApresValidation) {
 		vueExterneARafraichirApresValidation = vueARafraichirApresValidation;
 		initialiserPublicationForm(mediateurCourrant, publicationId);
+	}
+	 //-----------------------//
+	//    Initialisation     //------------------------------------------------------------
 	private void initialiserPublicationForm(Mediateur mediateurCourrant, String publicationId) {
 		sequenceur = new Sequenceur();
 		publication = new Publication();
 		publication.setId(publicationId);
+		this.publicationId = publicationId;
-		auteursInitialListe = new PersonneListe();
+		auteursInitialListe = new PublicationAPersonneListe();
 		initialiserAuteurs();	// Crée les listes d'auteurs ajoutés et supprimés
+		// Si 'publicationId' est vide alors on est en mode "AJOUTER", sinon on est en mode "MODIFIER"
-		String modeDeCreation = (UtilString.isEmpty(publicationId) ? Formulaire.MODE_AJOUTER : Formulaire.MODE_MODIFIER);
+		modeDeCreation = (UtilString.isEmpty(publicationId) ? 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, sequenceur);
 			mediateurCourrant.selectionnerPublicationAPersonne(this, publicationId, null, PublicationAPersonne.ROLE_AUTEUR, sequenceur);
 			sequenceur.enfilerRafraichissement(this, new Information("chargement_modifier_ok"));
+		}
+	}
+	private void initialiserAuteurs() {
+		auteursAjoutes = new PublicationAPersonneListe();
+		auteursSupprimes = new PublicationAPersonneListe();
+		auteursModifies = new PublicationAPersonneListe();
+	}
-	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();
-			}
 	//    User Interface     //------------------------------------------------------------
 	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);
+		barreOutils.add(new SeparatorToolItem());
+		barreOutils.add(new Text(i18nC.deplacerAuteur()));
+		boutonAuteurUp = creerBoutonAuteurUp();
+		barreOutils.add(boutonAuteurUp);
+		boutonAuteurDown = creerBoutonAuteurDown();
+		barreOutils.add(boutonAuteurDown);
 		return barreOutils;
+	}
+	public void actualiserEtatBoutonsBarreOutils() {
+		// Activation des boutons si la grille contient un élément
+		if (grilleAuteurs.getStore().getCount() > 0) {
+			personnesBoutonSupprimer.enable();
+			personnesBoutonModifier.enable();
+		}
+		// Désactivation des boutons si la grille ne contient plus d'élément
+		if (grilleAuteurs.getStore().getCount() == 0) {
+			personnesBoutonSupprimer.disable();
+			personnesBoutonModifier.disable();
+		}
+	}
+	private Button creerBoutonAuteurUp() {
+		Button bouton = new Button();
+		bouton.setIcon(Images.ICONES.arrowUp());
+		bouton.setEnabled(false);
+		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
+			public void componentSelected(ButtonEvent ce) {
+				if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
+					PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
+					int index = grilleAuteurs.getStore().indexOf(pap);
+					int newIndex = index;
+					newIndex--;
+					// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
+					// déclenchent et posent problème
+					changeOrderMarker = true;
+					pap.setOrdreAuteurs(String.valueOf(newIndex+1));
+					PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index-1);
+					int newIndexPapSwitch = index + 1;
+					papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
+					grilleAuteurs.getStore().update(papSwitch);
+					grilleAuteurs.getStore().remove(pap);
+					grilleAuteurs.getStore().insert(pap, newIndex);
+					changeOrderMarker = false;
+					grilleAuteurs.getSelectionModel().select(newIndex, true);
+				}
+			}
+		});
+		return bouton;
+	}
+	private Button creerBoutonAuteurDown() {
+		Button bouton = new Button();
+		bouton.setIcon(Images.ICONES.arrowDown());
+		bouton.setEnabled(false);
+		bouton.addSelectionListener(new SelectionListener<ButtonEvent>() {
+			public void componentSelected(ButtonEvent ce) {
+				if (grilleAuteurs.getSelectionModel().getSelectedItem() != null) {
+					PublicationAPersonne pap = grilleAuteurs.getSelectionModel().getSelectedItem();
+					int index = grilleAuteurs.getStore().indexOf(pap);
+					int newIndex = index;
+					newIndex++;
+					// le marqueur suivant est obligatoire sinon les évènements liés au magasin se
+					// déclenchent et posent problème
+					changeOrderMarker = true;
+					pap.setOrdreAuteurs(String.valueOf(newIndex+1));
+					PublicationAPersonne papSwitch = grilleAuteurs.getStore().getAt(index+1);
+					int newIndexPapSwitch = index + 1;
+					papSwitch.setOrdreAuteurs(String.valueOf(newIndexPapSwitch));
+					grilleAuteurs.getStore().update(papSwitch);
+					grilleAuteurs.getStore().remove(pap);
+					grilleAuteurs.getStore().insert(pap, newIndex);
+					changeOrderMarker = false;
+					grilleAuteurs.getSelectionModel().select(newIndex, true);
+				}
+			}
+		});
+		return bouton;
+	}
 	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();
+				Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
 				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();
+			Personne personneSaisieSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem().getPersonne();
 			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();
+				PublicationAPersonne personneSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
-				if (personneSaisieSelectionnee == null) {
+				if (personneSelectionnee == null) {
 					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPublication());
 				} else {
-					supprimerDansGrille(personneSaisieSelectionnee);
+					supprimerDansGrille(personneSelectionnee);
+				}
+			}
 		});
 		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();
+			grilleAuteurs.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_nom");
+		modelTypePersonnes.addField("cp_prenom");
 		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>(sequenceur);
 		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());
+					PublicationAPersonne pap = new PublicationAPersonne();
+					pap.setPersonne(personneSaisieSelectionnee);
+					if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
-					if (grille.getStore().findModel(personneSaisieSelectionnee) != null)	{
+					if (grilleAuteurs.getStore().findModel(pap) != 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);
+						ajouterDansGrille(pap);
 						personnesSaisiesComboBox.getCombo().setValue(null);
+					}
+				}
+			}
 		});
+	}
-	private void obtenirPersonnesSaisies(String nom) {
-		mediateur.selectionnerPersonneParNomComplet(this, null, nom+"%", null);
-	}
-	private void ajouterDansGrille(Personne personne) {
+	private void ajouterDansGrille(PublicationAPersonne pap) {
-		ajouterDansGrille(personne, 0);
+		ajouterDansGrille(pap, 0);
 	}
-	private void ajouterDansGrille(Personne personne, int index) {
+	private void ajouterDansGrille(PublicationAPersonne pap, int index) {
-		if (personne != null) {
+		if (pap != null) {
-			if (!grille.getStore().contains(personne))	{
+			if (!grilleAuteurs.getStore().contains(pap))	{
 				//1) si elle ne fait pas partie des initiaux, ajouter à la liste à ajouter
-				if (!auteursInitialListe.containsValue(personne))	{
+				if (!auteursInitialListe.containsValue(pap))	{
-					auteursAjoutes.put(personne.getId(), personne);
+					auteursAjoutes.put(pap.getId(), pap);
+				}
 				// L'enlever de la liste à supprimer
-				if (auteursSupprimes.containsValue(personne))	{
+				if (auteursSupprimes.containsValue(pap))	{
-					auteursSupprimes.remove(personne);
+					auteursSupprimes.remove(pap);
+				}
 				//2) Ajouter a la grille
-				grille.getStore().insert(personne, index);
+				grilleAuteurs.getStore().insert(pap, index);
-				grille.getSelectionModel().select(index, false);
+				grilleAuteurs.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) {
+	private void supprimerDansGrille(PublicationAPersonne pap) {
-		if (personne != null) {
+		if (pap != null) {
-			//1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
+			// 1) Ajouter a la liste des personne à supprimer uniquement si est présente dans la liste initiale
-			if (auteursInitialListe.containsValue(personne)) {
+			if (auteursInitialListe.containsValue(pap)) {
-				auteursSupprimes.put(personne.getId(), personne);
+				auteursSupprimes.put(pap.getId(), pap);
 			}
-			if (auteursAjoutes.containsValue(personne))	{
+			if (auteursAjoutes.containsValue(pap))	{
+				auteursAjoutes.remove(pap);
+			}
+			if (auteursModifies.containsValue(pap))	{
-				auteursAjoutes.remove(personne);
+				auteursModifies.remove(pap);
 			}
-			//2) Supprimer la personne de la liste
+			// 2) Supprimer la personne de la liste
-			grille.getStore().remove(personne);
+			grilleAuteurs.getStore().remove(pap);
 		} else {
 			Info.display("Information", "Vous devez sélectionner une personne");
+		}
+	}
+	private EditorGrid<PublicationAPersonne> creerGrilleAuteurs() {
-	private EditorGrid<Personne> creerGrille() {
+		ListStore<PublicationAPersonne> storeGrilleAuteurs = new ListStore<PublicationAPersonne>();
-		ListStore<Personne> storeGrille = new ListStore<Personne>();
+		// ADD Listener ------------------------------------------------------------------------------------
+		storeGrilleAuteurs.addListener(Store.Add, new Listener<StoreEvent<PublicationAPersonne>>() {
+			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
+				if (!changeOrderMarker) {
+					// Bug de GXT : Pour récupérer l'élément modifié, j'ai dû faire comme suit
+					ListStore<PublicationAPersonne> auteursStore = (ListStore<PublicationAPersonne>)ce.getSource();
+					PublicationAPersonne pap = auteursStore.getAt(ce.getIndex());
+					// Lorsque l'on reçoit une liste d'auteurs, on leur affecte l'état "modifié", puis
+					// on les ajoute au magasin mais puisque chaque élément ajouté au magasin déclenche
+					// l'évènement Store.Add, on est obligé de vérifier si l'objet n'a pas déjà un état
+					// sinon l'évènement écrase l'état précédent
-		storeGrille.addListener(Store.Add, new Listener<StoreEvent<Personne>>() {
+					if (pap.get("_etat_") == null) pap.set("_etat_", aDonnee.ETAT_AJOUTE);
-			public void handleEvent(StoreEvent<Personne> ce) {
+					actualiserEtatBoutonsBarreOutils();
 				actualiserEtatBoutonsBarreOutils();
+			}
 		});
+		// REMOVE Listener ------------------------------------------------------------------------------------
-		storeGrille.addListener(Store.Remove, new Listener<StoreEvent<Personne>>() {
+		storeGrilleAuteurs.addListener(Store.Remove, new Listener<StoreEvent<PublicationAPersonne>>() {
+			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
-			public void handleEvent(StoreEvent<Personne> ce) {
+				if (!changeOrderMarker) {
+					actualiserEtatBoutonsBarreOutils();
 				actualiserEtatBoutonsBarreOutils();
+			}
 		});
+		// UPDATE Listener ------------------------------------------------------------------------------------
-		storeGrille.addListener(Store.Update, new Listener<StoreEvent<Personne>>() {
+		storeGrilleAuteurs.addListener(Store.Update, new Listener<StoreEvent<PublicationAPersonne>>() {
+			public void handleEvent(StoreEvent<PublicationAPersonne> ce) {
+				if (!changeOrderMarker) {
+					if (ce.getRecord().isModified("ordre")) {
+						/** s'il s'agit d'un auteur que l'on vient d'ajouter à la liste, alors on a pas besoin
-			public void handleEvent(StoreEvent<Personne> ce) {
+						de faire quoique ce soit car l'auteur est déjà dans la liste des auteurs ajoutés **/
+						if (ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
+							// ... do nothing
+						/** s'il s'agit d'un auteur qui était déjà présent dans la liste initiale, il faut
+						ajouter cet auteur à la liste des auteurs modifiés **/
-				if (ce.getRecord().isModified("_role_") && !ce.getModel().get("_etat_").equals(aDonnee.ETAT_AJOUTE)) {
+						} else {
+							if (ce.getModel() instanceof PublicationAPersonne) {
+								PublicationAPersonne pap = ce.getModel();
+								auteursModifies.put(pap.getId(), pap);
+							}
+						}
 					ce.getModel().set("_etat_", aDonnee.ETAT_MODIFIE);
+				}
 			}
 		});
+		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
+		ColumnConfig columnOrdre = new ColumnConfig("ordre", i18nC.ordre(), 15);
+		/*
+		final TextField<String> ordre = new TextField<String>();
+		ordre.setValidator(new Validator(){
+			public String validate(Field<?> field, String value) {
+				if (value.matches("[0-9]*")) return null;
+				else return "[Erreur] Le champ 'ordre' doit être un nombre entier.";
+			}
+		});
+		*/
-		List<ColumnConfig> colonnes = new ArrayList<ColumnConfig>();
+		colonnes.add(columnOrdre);
 		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>();
+		GridSelectionModel<PublicationAPersonne> modeleDeSelection = new GridSelectionModel<PublicationAPersonne>();
 		ColumnModel modeleDeColonnes = new ColumnModel(colonnes);
+		EditorGrid<PublicationAPersonne> grilleDesAuteurs = new EditorGrid<PublicationAPersonne>(storeGrilleAuteurs, modeleDeColonnes);
+		modeleDeSelection.addListener(Events.SelectionChange, new SelectionChangedListener<PublicationAPersonne>() {
+			public void selectionChanged(SelectionChangedEvent<PublicationAPersonne> se) {
+				PublicationAPersonne papSelectionnee = grilleAuteurs.getSelectionModel().getSelectedItem();
+				int index = grilleAuteurs.getStore().indexOf(papSelectionnee);
+				if (index >= 1) boutonAuteurUp.setEnabled(true);
+				else boutonAuteurUp.setEnabled(false);
+				if ((index+1) < grilleAuteurs.getStore().getCount()) boutonAuteurDown.setEnabled(true);
+				else boutonAuteurDown.setEnabled(false);
+			}
+		});
-		EditorGrid<Personne> grillePublications = new EditorGrid<Personne>(storeGrille, modeleDeColonnes);
-		grillePublications.setHeight("100%");
+		grilleDesAuteurs.setHeight("100%");
-		grillePublications.setBorders(true);
+		grilleDesAuteurs.setBorders(true);
-		grillePublications.setSelectionModel(modeleDeSelection);
+		grilleDesAuteurs.setSelectionModel(modeleDeSelection);
-		grillePublications.getView().setForceFit(true);
+		grilleDesAuteurs.getView().setForceFit(true);
-		grillePublications.setAutoExpandColumn("fmt_nom_complet");
+		grilleDesAuteurs.setAutoExpandColumn("fmt_nom_complet");
-		grillePublications.setStripeRows(true);
+		grilleDesAuteurs.setStripeRows(true);
-		grillePublications.setTrackMouseOver(true);
+		grilleDesAuteurs.setTrackMouseOver(true);
-		return grillePublications;
+		return grilleDesAuteurs;
+	}
 	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.getTitre();
+			 }
+		}
 		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();
+		grilleAuteurs = creerGrilleAuteurs();
-		auteursFieldset.add(grille);
+		auteursFieldset.add(grilleAuteurs);
 		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>(sequenceur);
 		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>(sequenceur);
 		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
-			publication = (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);
-		}
-	}
-	private void synchronisation() {
+	 //-------------------------//
 	//    Méthodes privées     //------------------------------------------------------------
 	private void miseAJourAuteursInitialListe() {
 		Iterator<String> clesAjoutees = auteursAjoutes.keySet().iterator();
 		while (clesAjoutees.hasNext()) {
-			Personne auteurAjoute = auteursAjoutes.get(clesAjoutees.next());
+			PublicationAPersonne 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());
+			PublicationAPersonne auteurSupprime = auteursSupprimes.get(clesSupprimees.next());
 			auteursInitialListe.remove(auteurSupprime.getId());
+		}
+	}
-	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());
-		layout();
-	}
-	private void rafraichirInformation(Information info) {
-		String type = info.getType();
-		if (type.equals("publication_enregistree"))	{
-			// la publication vien d'etre enregistrée, on soumet les auteurs
-			soumettreAuteurs();
-		} else if (type.equals("auteurs_enregistres")) {
-			miseAJourAuteursInitialListe();
-			initialiserAuteurs();
-			repandreRafraichissement();
-			controlerFermeture();
-		} else if (type.equals("chargement_modifier_ok"))	{
-			peuplerFormulaire();
-			genererTitreFormulaire();
-		}
-		/*if (info.getType().equals("liste_personne")) {
-			PersonneListe listePersonneAuteur = (PersonneListe) info.getDonnee(0);
-			ListStore store = personnesSaisiesComboBox.getStore();
-			store.removeAll();
-			store.add(listePersonneAuteur.toList());
-		} else */
-		if (type.equals("personne_ajoutee")) {
-			if (info.getDonnee(0) != null) {
-				Personne personne = (Personne) info.getDonnee(0);
-				ajouterDansGrille(personne);
-			}
-		} else if (type.equals("personne_modifiee")) {
-			if (info.getDonnee(0) != null) {
-				Personne personne = (Personne) info.getDonnee(0);
-				Personne personneDansGrille = grille.getStore().findModel("id_personne", personne.getId());
-				int index = grille.getStore().indexOf(personneDansGrille);
-				grille.getStore().remove(personneDansGrille);
-				ajouterDansGrille(personne, index);
-			}
-		} 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 void initialiserAuteurs() {
-		auteursAjoutes = new PersonneListe();
-		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() {
 		boolean formulaireValideOk = verifierFormulaire();
 		if (formulaireValideOk) {
 			soumettrePublication();
+		}
 		return formulaireValideOk;
+	}
 	private void soumettrePublication() {
 		Publication publicationCollectee = collecterPublication();
 		if (publicationCollectee != null) {
-			// Pour l'enregistrement des collections, on utilise le séquenceur
+			// Pour l'enregistrement des publications, on utilise le séquenceur
 			// Il doit attendre le retour de l'enregistrement pour poursuivre
 			sequenceur = new Sequenceur();
 			int seqId = sequenceur.lancerRequeteSynchrone(this);
 			if (mode.equals(Formulaire.MODE_AJOUTER)) {
 				mediateur.ajouterPublication(sequenceur, publicationCollectee, seqId);
 			} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
 				mediateur.modifierPublication(sequenceur, publicationCollectee, seqId);
+			}
-			sequenceur.enfilerRafraichissement(this, new Information("publication_enregistree"));
+		// si l'on est en mode MODIFIER, on soumet les auteurs meme si les informations de la publication
+		// restent inchangées car il se peut que les auteurs aient été modifiés
+		} else if (mode.equals(Formulaire.MODE_MODIFIER)) {
+			soumettreAuteurs();
+		}
+	}
 	private void soumettreAuteurs() {
+		formaterOrdreAuteurs();
-		//1) Auteurs ajoutés :
-		// - Créer une PublicationAAuteurListe
+		//1) Auteurs ajoutés :
-		PublicationAPersonneListe listeDesAuteurs = new PublicationAPersonneListe();
+		PublicationAPersonneListe listeAuteursAAjouter = new PublicationAPersonneListe();
 		Iterator<String> itAuteur = auteursAjoutes.keySet().iterator();
-		while (itAuteur.hasNext())	{
-			PublicationAPersonne publiAPersonne = new PublicationAPersonne();
+		while (itAuteur.hasNext())	{
 			String cle = itAuteur.next();
-			publiAPersonne.setIdPersonne(cle);
+			PublicationAPersonne publiAPersonne = auteursAjoutes.get(cle);
+			publiAPersonne.setIdPublication(this.publicationId);
-			publiAPersonne.setIdPublication(publication.getId());
+			publiAPersonne.setOrdreAuteurs(publiAPersonne.getOrdreAuteurs());
-			listeDesAuteurs.put(cle, publiAPersonne);
+			listeAuteursAAjouter.put(cle, publiAPersonne);
+		}
 		// - envoyer au mediateur SSI personnes à ajouter
-		if (listeDesAuteurs.size() > 0)	{
+		if (listeAuteursAAjouter.size() > 0)	{
 			int seqId = sequenceur.lancerRequeteSynchrone(this);
-			mediateur.ajouterPublicationAPersonne(sequenceur, publication.getId(), listeDesAuteurs, PublicationAPersonne.ROLE_AUTEUR, seqId);
+			mediateur.ajouterPublicationAPersonne(sequenceur, this.publicationId, listeAuteursAAjouter, PublicationAPersonne.ROLE_AUTEUR, seqId);
-			//attenteAjoutAuteursOk = true;
+		}
 		//2) Auteurs supprimés :
-		// - Créer une PublicationAPersonneListe
-		listeDesAuteurs = new PublicationAPersonneListe();
+		PublicationAPersonneListe listeAuteursASupprimer = new PublicationAPersonneListe();
 		itAuteur = auteursSupprimes.keySet().iterator();
 		while (itAuteur.hasNext())	{
-			PublicationAPersonne publiAPersonne = new PublicationAPersonne();
 			String cle = itAuteur.next();
-			publiAPersonne.setIdPersonne(cle);
-			publiAPersonne.setIdPublication(publication.getId());
+			PublicationAPersonne publiAPersonne = auteursSupprimes.get(cle);
-			listeDesAuteurs.put(cle, publiAPersonne);
+			listeAuteursASupprimer.put(cle, publiAPersonne);
+		}
 		// - Envoyer au médiateur SSI personnes à supprimer
-		if (listeDesAuteurs.size() > 0) {
+		if (listeAuteursASupprimer.size() > 0) {
 			// Pour une suppression des auteurs, on a pas besoin d'attendre le retour
-			mediateur.supprimerPublicationAPersonne(this, listeDesAuteurs);
+			mediateur.supprimerPublicationAPersonne(this, listeAuteursASupprimer);
-			//attenteSuppressionAuteursOk = true;
+		}
+		//3) Auteurs modifiés :
-		sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres"));
-	}
+		PublicationAPersonneListe listeAuteursAModifier = new PublicationAPersonneListe();
-	public boolean verifierFormulaire() {
+		itAuteur = auteursModifies.keySet().iterator();
-		boolean valide = true;
+		while (itAuteur.hasNext())	{
-		ArrayList<String> messages = new ArrayList<String>();
+			String cle = itAuteur.next();
-		// Tester si au moins un auteur est présent
-		if (grille.getStore().getModels().size() == 0) {
+			PublicationAPersonne publiAPersonne = auteursModifies.get(cle);
-			messages.add("Veuillez saisir au moins un auteur.");
+			listeAuteursAModifier.put(cle, publiAPersonne);
 		}
-		String titre = titreChp.getValue();
+		// - Envoyer au médiateur SSI personnes à modifier
+		if (listeAuteursAModifier.size() > 0) {
-		if (titre == null || titre.equals("")) {
+			int seqId = sequenceur.lancerRequeteSynchrone(this);
+			mediateur.modifierPublicationAPersonne(sequenceur, publication.getId(), listeAuteursAModifier, PublicationAPersonne.ROLE_AUTEUR, seqId);
+		}
-			messages.add("Veuillez saisir le titre de la publication !");
+		sequenceur.enfilerRafraichissement(this, new Information("auteurs_enregistres"));
-		}
+	}
-		String uri = uriChp.getValue();
-		if (uri != null && ! uri.isEmpty() && ! uri.matches(Pattern.url)) {
+	private void formaterOrdreAuteurs() {
-			messages.add("L'URL saisie n'est pas valide !");
+		ListStore<PublicationAPersonne> store = grilleAuteurs.getStore();
-		}
+		List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
-		String datePublication = datePublicationChp.getRawValue();
+		Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
-		if (datePublication == null || datePublication.equals("")) {
+		while (itAuteurs.hasNext())	{
+			PublicationAPersonne pap = itAuteurs.next();
-			messages.add("Veuillez saisir une année de parution !");
+			int ordre = store.indexOf(pap) + 1;
-		} else {
+			if (pap.getOrdreAuteurs() != String.valueOf(ordre)) {
-			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);
+				pap.setOrdreAuteurs(String.valueOf(ordre));
-			valide = false;
+				auteursModifies.put(pap.getId(), pap);
+			}
 		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());
+			if (structure == null) editeur = editeurCombobox.getCombo().getRawValue();
-			editeur = structure.getNom();
+			else 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
+		// ranger par ordre désigné par le champ 'cpuap_ordre' de la table PublicationAPersonne
-		grille.getStore().sort("nom", SortDir.ASC);
+		grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
-		List<Personne> auteurs = grille.getStore().getModels();
+		List<PublicationAPersonne> auteurs = grilleAuteurs.getStore().getModels();
-		Iterator<Personne> itAuteurs = auteurs.iterator();
+		Iterator<PublicationAPersonne> itAuteurs = auteurs.iterator();
 		while (itAuteurs.hasNext())	{
-			Personne personneCourante = itAuteurs.next();
+			Personne personneCourante = itAuteurs.next().getPersonne();
 			intituleAuteur += personneCourante.getNom().toUpperCase() + " " + personneCourante.getPrenom();
 			if (itAuteurs.hasNext())	{
 				intituleAuteur+=", ";
+			}
+		}
 		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 "";
+		}
+	}
+	 //---------------------------//
+	//    Méthodes publiques     //------------------------------------------------------------
+	public boolean verifierFormulaire() {
+		boolean valide = true;
+		ArrayList<String> messages = new ArrayList<String>();
+		// Tester si au moins un auteur est présent
+		if (grilleAuteurs.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;
+	}
+	 //-------------------//
+	//    Accesseurs     //------------------------------------------------------------
 	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()));
+			}
+		}
+	}
+	 //-------------------//
+	//    Rafraichir     //------------------------------------------------------------
+	public void rafraichir(Object nouvellesDonnees) {
+		if (nouvellesDonnees instanceof Publication) {
+			publication = (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);
+		}
+	}
+	private void rafraichirListeAuteurs(PublicationAPersonneListe auteurs) {
+		Iterator<String> it = auteurs.keySet().iterator();
+		while (it.hasNext()) {
+			PublicationAPersonne auteur = auteurs.get(it.next());
+			auteur.set("_etat_", aDonnee.ETAT_MODIFIE);
+			auteursInitialListe.put(auteur.getId(), auteur);
+		}
+		grilleAuteurs.getStore().removeAll();
+		grilleAuteurs.getStore().add(auteursInitialListe.toList());
+		grilleAuteurs.getStore().sort("ordre", SortDir.ASC);
+		layout();
+	}
+	private void rafraichirInformation(Information info) {
+		String type = info.getType();
+		if (type.equals("auteurs_enregistres")) {
+			miseAJourAuteursInitialListe();
+			initialiserAuteurs();
+			repandreRafraichissement();
+			controlerFermeture();
+		} else if (type.equals("chargement_modifier_ok"))	{
+			peuplerFormulaire();
+			genererTitreFormulaire();
+		}
+		if (type.equals("personne_ajoutee")) {
+			if (info.getDonnee(0) != null) {
+				Personne personne = (Personne) info.getDonnee(0);
+				PublicationAPersonne pap = new PublicationAPersonne();
+				pap.setPersonne(personne);
+				if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
+				ajouterDansGrille(pap);
+			}
+		} else if (type.equals("personne_modifiee")) {
+			if (info.getDonnee(0) != null) {
+				// créer la nouvelle entrée
+				Personne personne = (Personne) info.getDonnee(0);
+				PublicationAPersonne pap = new PublicationAPersonne();
+				pap.setPersonne(personne);
+				if (modeDeCreation != Formulaire.MODE_AJOUTER) pap.setPublicationLiee(publication);
+				// supprimer l'entrée précédente
+				PublicationAPersonne personneDansGrille = grilleAuteurs.getStore().findModel("id_personne", personne.getId());
+				int index = grilleAuteurs.getStore().indexOf(personneDansGrille);
+				grilleAuteurs.getStore().remove(personneDansGrille);
+				// ajouter la nouvelle entrée dans la grille
+				ajouterDansGrille(pap, index);
+			}
+		} else if (info.getType().equals("modif_publication")) {
+			InfoLogger.display("Modification d'une publication", info.toString());
+			soumettreAuteurs();
+		} 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 idPublication = (String) info.getDonnee(0);
+				this.publicationId = idPublication;
+				soumettreAuteurs();
+				InfoLogger.display("Ajout d'une publication", "La publication '"+publicationId+"' a bien été ajoutée");
+			} else {
+				InfoLogger.display("Ajout d'une publication", info.toString());
+			}
+		}
+	}
+	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);
+		}
+	}
+}

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/vues/publication/PublicationForm.java – Rev 1417 → 1428