WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/vues/structure/StructureFormPersonne.java

 package org.tela_botanica.client.vues.structure;
 import java.util.ArrayList;
 import java.util.Collection;
 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.ChampComboBoxListeValeurs;
+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.images.Images;
 import org.tela_botanica.client.interfaces.Rafraichissable;
 import org.tela_botanica.client.modeles.Information;
 import org.tela_botanica.client.modeles.Valeur;
 import org.tela_botanica.client.modeles.ValeurListe;
 import org.tela_botanica.client.modeles.aDonnee;
 import org.tela_botanica.client.modeles.personne.Personne;
+import org.tela_botanica.client.modeles.structure.Structure;
 import org.tela_botanica.client.modeles.structure.StructureAPersonne;
 import org.tela_botanica.client.modeles.structure.StructureAPersonneListe;
 import org.tela_botanica.client.synchronisation.Sequenceur;
 import org.tela_botanica.client.util.Debug;
 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.FormulaireOnglet;
+import org.tela_botanica.client.vues.personne.PersonneForm;
 import com.extjs.gxt.ui.client.Style.Scroll;
 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.Listener;
 import com.extjs.gxt.ui.client.event.SelectionListener;
 import com.extjs.gxt.ui.client.store.ListStore;
 import com.extjs.gxt.ui.client.store.Record;
 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.TabItem;
+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.FormPanel;
 import com.extjs.gxt.ui.client.widget.form.NumberField;
 import com.extjs.gxt.ui.client.widget.form.TextArea;
 import com.extjs.gxt.ui.client.widget.form.TextField;
 import com.extjs.gxt.ui.client.widget.form.ComboBox.TriggerAction;
 import com.extjs.gxt.ui.client.widget.form.FormPanel.LabelAlign;
 import com.extjs.gxt.ui.client.widget.grid.CellEditor;
 import com.extjs.gxt.ui.client.widget.grid.CheckColumnConfig;
 import com.extjs.gxt.ui.client.widget.grid.ColumnConfig;
 import com.extjs.gxt.ui.client.widget.grid.ColumnModel;
 import com.extjs.gxt.ui.client.widget.grid.EditorGrid;
 import com.extjs.gxt.ui.client.widget.grid.GridSelectionModel;
 import com.extjs.gxt.ui.client.widget.grid.RowNumberer;
+import com.extjs.gxt.ui.client.widget.layout.FitData;
 import com.extjs.gxt.ui.client.widget.layout.FitLayout;
 import com.extjs.gxt.ui.client.widget.layout.FormLayout;
 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.i18n.client.NumberFormat;
+import com.google.gwt.user.client.Window;
 public class StructureFormPersonne extends FormulaireOnglet implements Rafraichissable {
 	private StructureAPersonneListe personnel = null;
 	private StructureAPersonneListe personnelAjoute = null;
 	private StructureAPersonneListe personnelModifie = null;
 	private StructureAPersonneListe personnelSupprime = null;
 	private NumberField nbreTotalPersonneStructureChp = null;
 	private EditorGrid<StructureAPersonne> grillePersonnel = null;
 	private ListStore<StructureAPersonne> personnelGrilleMagazin = null;
 	public ListStore<Valeur> fonctionsMagazin;
 	public ComboBox<Valeur> fonctionsCombo;
 	public ListStore<Valeur> magazinLiStatut;
 	public ComboBox<Valeur> comboLiStatut;
 	private ListStore<Personne> personneExistanteMagazin = null;
 	private ChampComboBoxRechercheTempsReelPaginable personneExistanteCombo = null;
 	private Button supprimerPersonnelBtn = null;
 	private CellEditor fonctionEditor = null;
 	private List<Valeur> fonctionsListe = null;
 	private String ID = "personnel";
 	private Formulaire formulaireCourant = null;
 	private int decompteRafraichissementPersonnel;
+	private FenetreForm fenetreFormulaire = null;
 	private Sequenceur sequenceur = null;
 	final class EtatPersonnelStructure {
 		public StructureAPersonneListe personnelModifie;
 		public StructureAPersonneListe personnelAjoute;
 		public StructureAPersonneListe personnelSupprime;
 		public StructureAPersonneListe personnel;
+	}
 	public StructureFormPersonne(Formulaire formulaireCourant, Mediateur mediateur) {
 		initialiserOnglet(formulaireCourant);
 		this.formulaireCourant = formulaireCourant;
 		// Création des objets contenant les manipulations de la grille
 		personnelModifie = new StructureAPersonneListe();
 		personnelAjoute = new StructureAPersonneListe();
 		personnelSupprime = new StructureAPersonneListe();
 		setId(ID);
 		setText(Mediateur.i18nC.personneSingulier());
 		FormulaireOnglet.parametrer(this);
 		this.setLayout(Formulaire.creerFormLayout(400, LabelAlign.LEFT));
 		this.setStyleAttribute("padding", "0");
 		this.addListener(Events.Select, new Listener<ComponentEvent>() {
 			public void handleEvent(ComponentEvent be) {
 				// Indique que l'onglet a été rempli et a pu être modifié pour la méthode collecter...
 				setData("acces", true);
 				// Rafraichissement du contenu de la grille du personnel
 				if (StructureFormPersonne.this.formulaireCourant.mode.equals(Formulaire.MODE_AJOUTER)) {
 					rafraichirPersonnel();
+				}
+			}
 		});
 		ContentPanel cp = new ContentPanel();
 		cp.setHeadingHtml("Personnes travaillant sur les collections");
 		cp.setIcon(Images.ICONES.table());
 		cp.setScrollMode(Scroll.AUTO);
 		cp.setLayout(new FitLayout());
 		//cp.setWidth(1250);
 		//cp.setHeight("100%");
 		cp.setFrame(true);
 		personnelGrilleMagazin = new ListStore<StructureAPersonne>();
 		personnelGrilleMagazin.setMonitorChanges(true);
 		personnelGrilleMagazin.addListener(Store.Add, new Listener<StoreEvent<StructureAPersonne>>() {
 			public void handleEvent(StoreEvent<StructureAPersonne> ce) {
 				// Activation du bouton supprimer si la grille contient un élément
 				if (grillePersonnel.getStore().getCount() > 0) {
 					supprimerPersonnelBtn.enable();
+				}
+			}
 		});
 		RowNumberer r = new RowNumberer();
 		List<ColumnConfig> configs = new ArrayList<ColumnConfig>();
 		GridSelectionModel<StructureAPersonne> sm = new GridSelectionModel<StructureAPersonne>();
 		configs.add(r);
 		ColumnConfig column = new ColumnConfig("fonction", "Fonction", 150);
 		fonctionsMagazin = new ListStore<Valeur>();
 		fonctionsCombo = new ComboBox<Valeur>();
 		fonctionsCombo.setTriggerAction(TriggerAction.ALL);
 		fonctionsCombo.setEditable(true);
 		fonctionsCombo.setDisplayField("nom");
 		fonctionsCombo.setStore(fonctionsMagazin);
 		mediateur.obtenirListeValeurEtRafraichir(this, "fonction", sequenceur);
 		fonctionEditor = new CellEditor(fonctionsCombo) {
 			@Override
 			public Object preProcessValue(Object valeur) {
 				Valeur retour = null;
 				if (valeur != null) {
 					String chaineTransmise = (String) valeur;
 					if (fonctionsMagazin.getCount() == 0 && fonctionsListe != null) {
 						fonctionsMagazin.add(fonctionsListe);
+					}
 					if (fonctionsMagazin.findModel("id_valeur", chaineTransmise) != null) {
 						retour = fonctionsMagazin.findModel("id_valeur", chaineTransmise);
 					} else if (fonctionsMagazin.findModel("nom", chaineTransmise) != null) {
 						retour = fonctionsMagazin.findModel("nom", chaineTransmise);
 					} else {
 						retour = new Valeur("", chaineTransmise, "", "");
+					}
+				}
 				return retour;
+			}
 			@Override
 			public Object postProcessValue(Object valeur) {
 				String retour = "";
 				Valeur fonctionTrouvee = null;
 				if (valeur == null) {
 					String valeurBrute = this.getField().getRawValue();
 					if (fonctionsMagazin.getCount() == 0 && fonctionsListe != null) {
 						fonctionsMagazin.add(fonctionsListe);
+					}
 					if (valeurBrute.matches("^[0-9]+$") && fonctionsMagazin.findModel("id_valeur", valeurBrute) != null) {
 						fonctionTrouvee = fonctionsMagazin.findModel("id_valeur", valeurBrute);
 					} else {
 						retour = valeurBrute;
+					}
 				} else if (valeur instanceof Valeur) {
 					fonctionTrouvee = (Valeur) valeur;
+				}
 				if (fonctionTrouvee != null) {
 					retour = fonctionTrouvee.getNom();
+				}
 				return retour;
+			}
 		};
 		column.setEditor(fonctionEditor);
 		configs.add(column);
 		column = new ColumnConfig("prenom", "Prénom", 100);
-		TextField<String> prenomChp = new TextField<String>();
-		prenomChp.setAllowBlank(false);
-		prenomChp.getMessages().setBlankText("Ce champ est obligatoire.");
-		prenomChp.setAutoValidate(true);
-		prenomChp.addStyleName(ComposantClass.OBLIGATOIRE);
-		prenomChp.addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
-		column.setEditor(new CellEditor(prenomChp));
 		configs.add(column);
 		column = new ColumnConfig("nom", "Nom", 100);
-		TextField<String> nomChp = new TextField<String>();
-		nomChp.setAllowBlank(false);
-		nomChp.getMessages().setBlankText("Ce champ est obligatoire.");
-		nomChp.setAutoValidate(true);
-		nomChp.addStyleName(ComposantClass.OBLIGATOIRE);
-		nomChp.addListener(Events.Valid, Formulaire.creerEcouteurChampObligatoire());
-		column.setEditor(new CellEditor(nomChp));
 		configs.add(column);
-		column = new ColumnConfig("tel_fix", "Téléphone fixe", 100);
-		TextField<String> telChp = new TextField<String>();
-		column.setEditor(new CellEditor(telChp));
+		column = new ColumnConfig("tel_fix", "Téléphone", 100);
 		configs.add(column);
 		column = new ColumnConfig("tel_fax", "Fax", 100);
-		TextField<String> faxChp = new TextField<String>();
-		column.setEditor(new CellEditor(faxChp));
 		configs.add(column);
 		column = new ColumnConfig("courriel", "Courriel principal", 200);
-		TextField<String> emailChp = new TextField<String>();
-		column.setEditor(new CellEditor(emailChp));
 		configs.add(column);
 		magazinLiStatut = new ListStore<Valeur>();
 		magazinLiStatut.add(new ArrayList<Valeur>());
 		comboLiStatut = new ComboBox<Valeur>();
 		comboLiStatut.setTriggerAction(TriggerAction.ALL);
 		comboLiStatut.setEditable(false);
 		comboLiStatut.disableTextSelection(true);
 		comboLiStatut.setDisplayField("nom");
 		comboLiStatut.setStore(magazinLiStatut);
 		mediateur.obtenirListeValeurEtRafraichir(this, "statut", sequenceur);
 		CellEditor statutEditor = new CellEditor(comboLiStatut) {
 			@Override
 			public Object preProcessValue(Object value) {
 				if (value == null) {
 					return value;
+				}
 				return comboLiStatut.getStore().findModel("nom", (String) value);
+			}
 			@Override
 			public Object postProcessValue(Object value) {
 				if (value == null) {
 					return value;
+				}
 				return ((Valeur) value).get("nom");
+			}
 		};
 		column = new ColumnConfig("statut", "Statut", 100);
 		column.setEditor(statutEditor);
 		configs.add(column);
 		column = new ColumnConfig("travail", "Travail hebdo (%)", 100);
 		column.setNumberFormat(NumberFormat.getFormat("##"));
 		NumberField tpsWChp = new NumberField();
 		tpsWChp.setFormat(NumberFormat.getFormat("##"));
 		tpsWChp.setToolTip("Ce champ doit contenir un nombre");
 		column.setEditor(new CellEditor(tpsWChp));
 		configs.add(column);
-		column = new ColumnConfig("specialite", "Spécialité principale", 150);
-		TextField<String> speChp = new TextField<String>();
-		column.setEditor(new CellEditor(speChp));
+		column = new ColumnConfig("specialite", "Spécialité botanique principale", 150);
 		configs.add(column);
 		CheckColumnConfig checkColumn = new CheckColumnConfig("contact", "Contact ?", 60);
 		configs.add(checkColumn);
 		ToolBar toolBar = new ToolBar();
+		personneExistanteMagazin = new ListStore<Personne>();
+		personneExistanteMagazin.add(new ArrayList<Personne>());
+		ModelType modelTypePersonnes = new ModelType();
-		Button ajouterPersonnelBtn = new Button("Ajouter");
+		modelTypePersonnes.setRoot("personnes");
+		modelTypePersonnes.setTotalName("nbElements");
+		modelTypePersonnes.addField("cp_fmt_nom_complet");
+		modelTypePersonnes.addField("cp_nom");
+		modelTypePersonnes.addField("cp_prenom");
+		modelTypePersonnes.addField("cp_truk_courriel");
+		modelTypePersonnes.addField("cp_truk_telephone");
+		modelTypePersonnes.addField("cp_ce_truk_specialite");
+		modelTypePersonnes.addField("cp_id_personne");
-		ajouterPersonnelBtn.setIcon(Images.ICONES.vcardAjouter());
+		String displayNamePersonnes = "cp_fmt_nom_complet";
+		ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>(null);
+		personneExistanteCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
+		personneExistanteCombo.getCombo().setEmptyText("Rechercher et sélectionner une personne existante dans la base");
-		ajouterPersonnelBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
+		// TODO : dans GXT 2.0 plus besoin de l'adaptateur, on peut ajouter la combobox directement sur la toolbar
+			//> CHECK
+		toolBar.add(personneExistanteCombo);
-			@Override
+		personneExistanteCombo.getCombo().addListener(Events.Select, new Listener<BaseEvent>() {
+			public void handleEvent(BaseEvent be) {
+				if (personneExistanteCombo.getValeur() instanceof ModelData) {
-			public void componentSelected(ButtonEvent ce) {
+					Personne personneExistante = new Personne(personneExistanteCombo.getValeur());
-				StructureAPersonne membreDuPersonnel = new StructureAPersonne("", StructureAPersonne.ROLE_EQUIPE, StructureAPersonne.ETAT_AJOUTE);
+					StructureAPersonne membreDuPersonnel = new StructureAPersonne(personneExistante, "", StructureAPersonne.ROLE_EQUIPE, StructureAPersonne.ETAT_AJOUTE);
+					ajouterMembreAGrillePersonnel(membreDuPersonnel);
+					personneExistanteCombo.getCombo().setValue(null);
-				ajouterMembreAGrillePersonnel(membreDuPersonnel);
+				}
+			}
+		});
+		toolBar.add(new Text(" ou "));
-		});
+		Button ajouterPersonnelBtn = creerBoutonAjouter();
+		toolBar.add(ajouterPersonnelBtn);
+		toolBar.add(new SeparatorToolItem());
+		Button modifierPersonnelBtn = creerBoutonModifier();
-		toolBar.add(ajouterPersonnelBtn);
+		toolBar.add(modifierPersonnelBtn);
 		toolBar.add(new SeparatorToolItem());
 		supprimerPersonnelBtn = new Button("Supprimer");
 		supprimerPersonnelBtn.setIcon(Images.ICONES.vcardSupprimer());
 		supprimerPersonnelBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
 			@Override
 			public void componentSelected(ButtonEvent ce) {
 				StructureAPersonne personne = grillePersonnel.getSelectionModel().getSelectedItem();
 				if (personne != null) {
 					// Ajout de la personne supprimée à la liste
 					if (personne.getIdPersonne() != null && !personne.getIdPersonne().equals("")) {
 						personnelSupprime.put(personne.getId(), personne);
+					}
 					// Suppression de l'enregistrement de la grille
 					grillePersonnel.getStore().remove(personne);
 					// Désactivation du bouton supprimer si la grille contient plus d'élément
 					if (grillePersonnel.getStore().getCount() == 0) {
 						//TODO : check : Item -> component
 						ce.getComponent().disable();
+					}
+				}
+			}
 		});
 		toolBar.add(supprimerPersonnelBtn);
 		toolBar.add(new SeparatorToolItem());
 		Button rafraichirPersonnelBtn = new Button("Rafraichir");
 		rafraichirPersonnelBtn.setIcon(Images.ICONES.rafraichir());
 		rafraichirPersonnelBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
 			@Override
 			public void componentSelected(ButtonEvent ce) {
 				rafraichirPersonnel();
+			}
 		});
 		toolBar.add(rafraichirPersonnelBtn);
 		toolBar.add(new SeparatorToolItem());
-		personneExistanteMagazin = new ListStore<Personne>();
-		personneExistanteMagazin.add(new ArrayList<Personne>());
-		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_truk_courriel");
-		modelTypePersonnes.addField("cp_truk_telephone");
-		modelTypePersonnes.addField("cp_ce_truk_specialite");
-		modelTypePersonnes.addField("cp_id_personne");
-		String displayNamePersonnes = "cp_fmt_nom_complet";
-		ProxyPersonnes<ModelData> proxyPersonnes = new ProxyPersonnes<ModelData>(null);
-		personneExistanteCombo = new ChampComboBoxRechercheTempsReelPaginable(proxyPersonnes, modelTypePersonnes, displayNamePersonnes);
-		// TODO : dans GXT 2.0 plus besoin de l'adaptateur, on peut ajouter la combobox directement sur la toolbar
-			//> CHECK
-		toolBar.add(personneExistanteCombo);
-		Button ajouterPersonneExistanteBtn = new Button("Ajouter à la grille");
-		ajouterPersonneExistanteBtn.addSelectionListener(new SelectionListener<ButtonEvent>() {
-			@Override
-			public void componentSelected(ButtonEvent ce) {
-				Personne personneExistante = new Personne(personneExistanteCombo.getValeur());
-				if (personneExistante != null) {
-					StructureAPersonne membreDuPersonnel = new StructureAPersonne(personneExistante, "", StructureAPersonne.ROLE_EQUIPE, StructureAPersonne.ETAT_AJOUTE);
-					ajouterMembreAGrillePersonnel(membreDuPersonnel);
-				}
-			}
-		});
-		toolBar.add(ajouterPersonneExistanteBtn);
 		cp.setTopComponent(toolBar);
 		ColumnModel cm = new ColumnModel(configs);
 		grillePersonnel = new EditorGrid<StructureAPersonne>(personnelGrilleMagazin, cm);
-		grillePersonnel.setHeight("100%");
+		//grillePersonnel.setHeight("100%");
+		grillePersonnel.setAutoHeight(true);
 		grillePersonnel.setBorders(true);
 		grillePersonnel.setSelectionModel(sm);
 		grillePersonnel.addPlugin(checkColumn);
 		grillePersonnel.addPlugin(r);
 		grillePersonnel.getView().setForceFit(true);
   		grillePersonnel.setAutoExpandColumn("specialite");
   		grillePersonnel.setStripeRows(true);
   		grillePersonnel.setTrackMouseOver(true);
 		personnelGrilleMagazin.addListener(Store.Update, new Listener<StoreEvent<StructureAPersonne>>() {
 			public void handleEvent(StoreEvent<StructureAPersonne> ce) {
 				StructureAPersonne structureAPersonne = ce.getModel();
 				String etat = structureAPersonne.get("etat");
 				if ((etat==null || !etat.equals(aDonnee.ETAT_AJOUTE)) && structureAPersonne!=null && !UtilString.isEmpty(structureAPersonne.getId()))	{
 					ce.getModel().set("etat", aDonnee.ETAT_MODIFIE);
+				}
+			}
 		});
   		cp.add(grillePersonnel);
 		this.add(cp);
+		this.setAutoHeight(true);
+	}
+	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) {
+				String IdpersonneSaisieSelectionnee = (grillePersonnel.getSelectionModel().getSelectedItem()).getIdPersonne();
+				if (IdpersonneSaisieSelectionnee == null) {
+					InfoLogger.display(i18nC.informationTitreGenerique(), i18nC.selectionnerPersonne());
+				} else {
+					fenetreFormulaire = creerFenetreModaleAvecFormulairePersonne(Formulaire.MODE_MODIFIER);
+					fenetreFormulaire.show();
+				}
+			}
+		});
+		return bouton;
+	}
+	private FenetreForm creerFenetreModaleAvecFormulairePersonne(String mode) {
+		String personneId = null;
+		if (mode.equals(Formulaire.MODE_MODIFIER)) {
+			personneId = (grillePersonnel.getSelectionModel().getSelectedItem()).getIdPersonne();
+		}
+		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.setHeadingHtml(panneauFormulaire.getHeadingHtml());
+		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();
+				}
+			}
+		};
+		return ecouteur;
+	}
 	public Collection<? extends String> verifier() {
 		ArrayList<String> messages = new ArrayList<String>();
 		// Vérification du Personnel
 		if (getData("acces").equals(true)) {
 			String personnelNumero = "";
 			int nbrePersonne = personnelGrilleMagazin.getCount();
 			for (int i = 0; i < nbrePersonne; i++) {
 				StructureAPersonne personne = personnelGrilleMagazin.getAt(i);
 				if (personne.getNom().equals("") || personne.getPrenom().equals("")) {
 					personnelNumero += (i != 0 ? ", " : "")+(i+1);
+				}
+			}
 			if (!personnelNumero.equals("")) {
 				messages.add("Veuillez indiquez un prénom et un nom au personnel numéro : "+personnelNumero);
+			}
+		}
 		return messages;
+	}
 	@Override
 	public void rafraichir(Object nouvellesDonnees) {
 		if (nouvellesDonnees instanceof ValeurListe) {
 			ValeurListe listeValeurs = (ValeurListe) nouvellesDonnees;
 			rafraichirValeurListe(listeValeurs);
 		} else if (nouvellesDonnees instanceof Information) {
 			Information info = (Information) nouvellesDonnees;
 			rafraichirInformation(info);
 		} else {
 			Debug.log(Mediateur.i18nM.erreurRafraichir(nouvellesDonnees.getClass(), this.getClass()));
+		}
+	}
 	public void rafraichirInformation(Information info) {
 		if (info.getType().equals("ajout_structure")) {
 			if (info.getDonnee(0) != null && info.getDonnee(0) instanceof String) {
 				String structureId = (String) info.getDonnee(0);
 				// Suite à la récupération de l'id de l'institution nouvellement ajoutée nous ajoutons le personnel
 				mediateur.ajouterStructureAPersonne(this, structureId, getPersonnelAjoute());
+			}
 		} else if (info.getType().equals("modif_structure_a_personne")) {
 			InfoLogger.display("Modification du Personnel", info.toString());
 			testerLancementRafraichirPersonnel();
 		} else if (info.getType().equals("suppression_structure_a_personne")) {
 			InfoLogger.display("Suppression du Personnel", info.toString());
 			testerLancementRafraichirPersonnel();
 		} else if (info.getType().equals("ajout_structure_a_personne")) {
 			InfoLogger.display("Ajout du Personnel", info.toString());
 			testerLancementRafraichirPersonnel();
 		} else if (info.getType().equals("liste_structure_a_personne")) {
 			if (info.getDonnee(0) != null) {
 				StructureAPersonneListe personnel = (StructureAPersonneListe) info.getDonnee(0);
 				peupler(personnel);
 				layout();
 				InfoLogger.display("Chargement du Personnel", "ok");
+			}
+		} else if (info.getType().equals("personne_modifiee")) {
+			if (info.getDonnee(0) != null) {
+				Personne personne = (Personne) info.getDonnee(0);
+				StructureAPersonne personneDansGrille = grillePersonnel.getStore().findModel("id_personne", personne.getId());
+				StructureAPersonne personneDansGrilleModif = new StructureAPersonne(personne, personneDansGrille.getFonction(), personneDansGrille.getIdRole(), personneDansGrille.getIdEtat());
+				int index = grillePersonnel.getStore().indexOf(personneDansGrille);
+				grillePersonnel.getStore().remove(personneDansGrille);
+				grillePersonnel.getStore().insert(personneDansGrilleModif, index);
+				personnelModifie.put(personne.getId()+"", personneDansGrilleModif);
+			}
+		} else if (info.getType().equals("personne_ajoutee")) {
+			if (info.getDonnee(0) != null) {
+				Personne personne = (Personne) info.getDonnee(0);
+				StructureAPersonne structAPersonne = new StructureAPersonne(personne,"",StructureAPersonne.ROLE_EQUIPE, "");
+				Structure structure = ((StructureForm) formulaire).identification;
+				structAPersonne.setIdStructure(structure.getId());
+				personnelAjoute.put(personne.getId(), structAPersonne);
+				ajouterMembreAGrillePersonnel(structAPersonne);
+			}
+		}
+	}
 	public void rafraichirValeurListe(ValeurListe listeValeurs) {
 		List<Valeur> liste = listeValeurs.toList();
 		if (listeValeurs.getId().equals(config.getListeId("statut"))) {
 			magazinLiStatut.removeAll();
 			magazinLiStatut.add(liste);
 			comboLiStatut.setStore(magazinLiStatut);
+		}
 		if (listeValeurs.getId().equals(config.getListeId("fonction"))) {
 			// FIXME : le store ne contient pas tout le temps les données, chose étrange.
 			// On stocke donc les données dans une variables de la classe pour recharger le store si besoin.
 			fonctionsListe = liste;
 			fonctionsMagazin.removeAll();
 			fonctionsMagazin.add(liste);
 			fonctionsCombo.setStore(fonctionsMagazin);
+		}
+	}
 	public EtatPersonnelStructure collecter() {
 		StructureForm formulaire = (StructureForm)formulaireCourant;
 		if (getData("acces").equals(true)) {
 			personnelGrilleMagazin.commitChanges();
 			int nbrePersonne = personnelGrilleMagazin.getCount();
 			for (int i = 0; i < nbrePersonne; i++) {
 				StructureAPersonne personne = personnelGrilleMagazin.getAt(i);
 				// Seules les lignes ajoutées ou modifiées sont prises en compte.
 				Record record = personnelGrilleMagazin.getRecord(personne);
 				if (personnelGrilleMagazin.getModifiedRecords().contains(record) == true
 						|| (personne.get("etat") != null && (personne.get("etat").equals(StructureAPersonne.ETAT_AJOUTE) || personne.get("etat").equals(StructureAPersonne.ETAT_MODIFIE)) )) {
 					// Gestion de l'id de la structure
 					if (mode.equals("MODIF")) {
 						personne.setIdStructure(getIdIdentification());
+					}
 					// Gestion de la fonction
 					String fonction = personne.get("fonction");
 					if (fonction != null && !fonction.equals("")) {
 						Valeur valeurRecherche = fonctionsCombo.getStore().findModel("nom", fonction);
 						if (valeurRecherche != null) {
 							personne.setFonction(valeurRecherche.getId());
 						} else {
 							personne.setFonction("AUTRE", fonction);
+						}
 					} else {
 						personne.setFonction("");
+					}
 					// Gestion du nom complet
 					String nomComplet = personne.getPrenom()+" "+personne.getNom();
 					personne.setNomComplet(nomComplet);
 					// Gestion de la notion de "contact"
 					personne.setContact(false);
 					if (personne.get("contact").equals(true)) {
 						personne.setContact(true);
+					}
 					// Gestion du statut
 					String statut = personne.get("statut");
 					if (statut != null && !statut.equals("")) {
 						Valeur valeurRecherche = comboLiStatut.getStore().findModel("nom", statut);
 						if (valeurRecherche != null) {
 							personne.setStatut(valeurRecherche.getId());
 						} else {
 							personne.setStatut("AUTRE", statut);
+						}
 					} else {
 						personne.setStatut("");
+					}
 					// Gestion du temps de travail
 					String personneTravail = "";
 					if(personne.get("travail") != null) {
 						personneTravail = personne.get("travail").toString();
+					}
 					personne.setBotaTravailHebdoTps(personneTravail);
 					// Gestion du téléphone
 					String telephoneFixe = personne.get("tel_fix");
 					personne.setTelephoneFixe(telephoneFixe);
 					// Gestion du fax
 					String fax = personne.get("tel_fax");
 					personne.setFax(fax);
 					// Gestion du courriel
 					String courriel = personne.get("courriel");
 					personne.setCourriel(courriel);
 					// Gestion de la spécialité
 					String specialite = personne.get("specialite");
 					personne.setSpecialite(specialite);
 					// On met à faux le décès
 					personne.setDeces(Personne.ETRE_VIVANT);
 					// Ajout de la personne dans la liste correspondant à son état (ajouté ou modifié)
 					if (personne.get("etat") != null && personne.get("etat").equals(StructureAPersonne.ETAT_AJOUTE)) { // Une personne ajoutée
 						personnelAjoute.put(""+i, personne);
 					} else {// Une personne modifiée
 						personnelModifie.put(personne.getId(), personne);
+					}
 				} else {
 					GWT.log("Personne non modifiées : "+personne.getPrenom()+" "+personne.getNom(), null);
+				}
+			}
+		}
 		EtatPersonnelStructure etatPersonnel = new EtatPersonnelStructure();
 		etatPersonnel.personnelAjoute = personnelAjoute;
 		etatPersonnel.personnelModifie = personnelModifie;
 		etatPersonnel.personnelSupprime = personnelSupprime;
 		// Remise à zéro des modification dans la liste du personnel
 		personnelModifie = new StructureAPersonneListe();
 		personnelAjoute = new StructureAPersonneListe();
 		personnelSupprime = new StructureAPersonneListe();
 		return etatPersonnel;
+	}
 	public void peupler(StructureAPersonneListe personnel) {
 		//this.personnel = personnel;
 		if (formulaireCourant.mode.equals(Formulaire.MODE_MODIFIER) && personnel != null) {
 			ArrayList<StructureAPersonne> personnes = new ArrayList<StructureAPersonne>();
 			for (Iterator<String> it = personnel.keySet().iterator(); it.hasNext();) {
 				String index = it.next();
 				// Gestion de la fonction
 				if (fonctionsMagazin != null && !((String) personnel.get(index).getFonction()).startsWith("AUTRE##")) {
 					if (fonctionsMagazin.findModel("id_valeur", personnel.get(index).getFonction()) != null) {
 						personnel.get(index).set("fonction", fonctionsMagazin.findModel("id_valeur", personnel.get(index).getFonction()).getNom());
+					}
 				} else {
 					personnel.get(index).set("fonction", personnel.get(index).getFonction().replaceFirst("AUTRE##", ""));
+				}
 				// Gestion de la notion de "contact"
 				personnel.get(index).set("contact", (personnel.get(index).getContact().equals("1") ? true : false));
 				// Gestion du statut
 				if (magazinLiStatut != null && ((String) personnel.get(index).getStatut()).matches("^[0-9]+$")) {
 					personnel.get(index).set("statut", magazinLiStatut.findModel("id_valeur", personnel.get(index).getStatut()).getNom());
 				} else {
 					personnel.get(index).set("statut", personnel.get(index).getStatut().replaceFirst("AUTRE##", ""));
+				}
 				// Gestion de la specialite
 				if (((String) personnel.get(index).getSpecialite()).matches("^[0-9]+$")) {
 					// Author : Cyprien
 					// TODO
 					// Ici faire un combobox ?
 					// ...
 				} else {
 					personnel.get(index).set("specialite", personnel.get(index).getSpecialite().replaceFirst("AUTRE##", ""));
+				}
 				// Gestion du temps de travail
 				String tps = personnel.get(index).getBotaTravailHebdoTps();
 				personnel.get(index).set("travail", (tps.matches("^[0-9]+$")  ? Integer.parseInt(tps) : 0));
 				personnes.add(personnel.get(index));
+			}
 			personnelGrilleMagazin.removeAll();
 			personnelGrilleMagazin.add(personnes);
 			// Remise à zéro des modification dans la liste du personnel
 			personnelModifie = new StructureAPersonneListe();
 			personnelAjoute = new StructureAPersonneListe();
 			personnelSupprime = new StructureAPersonneListe();
 			// Nous vidons la variable personnel une fois qu'elle a remplie la grille
 			personnel = null;
+		}
+	}
 	public StructureAPersonneListe getPersonnelAjoute() {
 		return personnelAjoute;
+	}
 	private void ajouterMembreAGrillePersonnel(StructureAPersonne personnel) {
 		grillePersonnel.stopEditing();
 		personnelGrilleMagazin.insert(personnel, 0);
 		grillePersonnel.startEditing(0, 0);
+	}
 	public void testerLancementRafraichirPersonnel() {
 		decompteRafraichissementPersonnel--;
 		if (decompteRafraichissementPersonnel <= 0) {
 			// Nous rechargeons la liste du Personnel
 			rafraichirPersonnel();
+		}
+	}
 	private void rafraichirPersonnel() {
 		decompteRafraichissementPersonnel = 0;
 		if (formulaireCourant.mode.equals(Formulaire.MODE_MODIFIER)) {
 			initialiserGrillePersonnelEnModification();
 		} else if (formulaireCourant.mode.equals(Formulaire.MODE_AJOUTER)) {
 			initialiserGrillePersonnelEnAjout();
+		}
+	}
 	private void rafraichirPersonneExistante(String nom) {
 		mediateur.selectionnerPersonneParNomComplet(this, nom+"%", null);
+	}
 	public void incrementerDecompteRafraichissementPersonnel() {
 		decompteRafraichissementPersonnel++;
+	}
 	private void initialiserGrillePersonnelEnAjout() {
 		personnelGrilleMagazin.removeAll();
 		layout();
+	}
 	private String getIdIdentification() {
 		return ((StructureForm)formulaireCourant).getIdIdentification();
+	}
 	private void initialiserGrillePersonnelEnModification() {
 		mediateur.selectionnerStructureAPersonne(this, getIdIdentification(), StructureAPersonne.ROLE_EQUIPE, null);
+	}
+}

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/vues/structure/StructureFormPersonne.java – Rev 1764 → 1779