WebSVN – eFlore/Applications.coel – Diff – /trunk/src/org/tela_botanica/client/Mediateur.java


package org.tela_botanica.client;
 
import java.util.Iterator;
import java.util.List;
 
import org.tela_botanica.client.composants.AideFenetre;
import org.tela_botanica.client.composants.IdentificationFenetre;
import org.tela_botanica.client.composants.ParametreFenetre;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.Information;
import org.tela_botanica.client.modeles.MenuApplicationId;
import org.tela_botanica.client.modeles.Personne;
import org.tela_botanica.client.modeles.PersonneListe;
import org.tela_botanica.client.modeles.Projet;
import org.tela_botanica.client.modeles.ProjetListe;
import org.tela_botanica.client.modeles.Publication;
import org.tela_botanica.client.modeles.PublicationListe;
import org.tela_botanica.client.modeles.Structure;
import org.tela_botanica.client.modeles.StructureAPersonne;
import org.tela_botanica.client.modeles.StructureAPersonneListe;
import org.tela_botanica.client.modeles.StructureConservation;
import org.tela_botanica.client.modeles.StructureListe;
import org.tela_botanica.client.modeles.StructureValorisation;
import org.tela_botanica.client.modeles.Utilisateur;
import org.tela_botanica.client.modeles.ValeurListe;
import org.tela_botanica.client.vues.ContenuPanneauVue;
import org.tela_botanica.client.vues.EntetePanneauVue;
import org.tela_botanica.client.vues.FormPersonneVue;
import org.tela_botanica.client.vues.FormPublicationVue;
import org.tela_botanica.client.vues.FormStructureVue;
import org.tela_botanica.client.vues.PersonneDetailPanneauVue;
import org.tela_botanica.client.vues.PersonneVue;
import org.tela_botanica.client.vues.PopupChargement;
import org.tela_botanica.client.vues.PublicationDetailPanneauVue;
import org.tela_botanica.client.vues.PublicationVue;
import org.tela_botanica.client.vues.StatutPanneauVue;
import org.tela_botanica.client.vues.StructureDetailPanneauVue;
import org.tela_botanica.client.vues.StructureVue;
import org.tela_botanica.client.vues.MenuPanneauVue;
 
import com.extjs.gxt.ui.client.Registry;
import com.extjs.gxt.ui.client.Style.LayoutRegion;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Dialog;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.StatusBar;
import com.extjs.gxt.ui.client.widget.Viewport;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.layout.BorderLayout;
import com.extjs.gxt.ui.client.widget.layout.BorderLayoutData;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.RootPanel;
 
public class Mediateur implements Rafraichissable {
	
	private Viewport viewport;
	private Modele modele = null;
	public Constantes i18nC;
	
	private EntetePanneauVue panneauNord = null;
	private MenuPanneauVue panneauOuest = null;
	private ContenuPanneauVue panneauCentre = null;
	private StatutPanneauVue panneauSud = null;
	private Rafraichissable contenuPanneauCentre = null;
	
	private IdentificationFenetre fenetreIdentification = null;
	
	public Mediateur() {
		// Enregistrement du Médiateur dans le Registre
		Registry.register(RegistreId.MEDIATEUR, this);
		// Gestion de l'i18n
		i18nC = GWT.create(Constantes.class);
		// Création du Modèle qui s'enregistre lui même dans le Registre
		modele = new Modele();
	    // Création de l'utilisateur courrant
		Registry.register(RegistreId.UTILISATEUR_COURANT, new Utilisateur(null, false));
		this.connecterUtilisateur(null, null);
	    // Création du projet courrant
		Registry.register(RegistreId.PROJET_COURANT, new Projet());
		
		// Création du Viewport qui contient la disposition globale de l'application
		viewport = new Viewport();
		viewport.setLayout(new BorderLayout());
		
		// Création des différents panneaux
	    creerPanneauNord();
	    creerPanneauOuest();
	    creerPanneauCentral();
	    creerPanneauSud();
 
		// Registry utile car présent partout!
		Registry.register(RegistreId.VIEWPORT, viewport);
		Registry.register(RegistreId.PANNEAU_OUEST, panneauOuest);
		Registry.register(RegistreId.PANNEAU_CENTRE, panneauCentre);
		Registry.register(RegistreId.PANNEAU_SUD, panneauSud);
 
		// Chargement du menu
		chargeMenuApplication();
		
		// Retour à GWT du Viewport une fois constuit
		RootPanel.get().add(viewport);
		
		masquerPopinChargement(); 
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION des PANNEAUX PRINCIPAUX
	//+----------------------------------------------------------------------------------------------------------------+
	
	private void creerPanneauNord() {
		panneauNord = new EntetePanneauVue(this);
		
		BorderLayoutData regionNord = new BorderLayoutData(LayoutRegion.NORTH, 100);  
		regionNord.setCollapsible(true);
		regionNord.setFloatable(true);
		regionNord.setSplit(false);
		regionNord.setMargins(new Margins(5, 5, 0, 5));
		
		viewport.add(panneauNord, regionNord);
	}
	
	private void creerPanneauOuest() {
		panneauOuest = new MenuPanneauVue(); 
		
		BorderLayoutData regionOuest = new BorderLayoutData(LayoutRegion.WEST, 200);  
		regionOuest.setSplit(true);
		regionOuest.setCollapsible(true);  
		regionOuest.setMargins(new Margins(5));
 
		viewport.add(panneauOuest, regionOuest);
	}
 
	private void creerPanneauCentral() {
		panneauCentre = new ContenuPanneauVue(this);
 
		BorderLayoutData regionCentre = new BorderLayoutData(LayoutRegion.CENTER);  
		regionCentre.setMargins(new Margins(5, 5, 5, 0));
 
		viewport.add(panneauCentre, regionCentre);
	}
	
	private void creerPanneauSud() {
		panneauSud = new StatutPanneauVue();
		
		BorderLayoutData regionSud = new BorderLayoutData(LayoutRegion.SOUTH, 20); 
		regionSud.setCollapsible(true);
		regionSud.setFloatable(true);
		regionSud.setSplit(false);
		regionSud.setMargins(new Margins(0));
		
		viewport.add(panneauSud, regionSud);
	}
 
	public void actualiserPanneauCentral() {
		panneauCentre.layout();
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION du MENU
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void chargeMenuApplication() {
		((MenuPanneauVue) Registry.get(RegistreId.PANNEAU_OUEST)).chargerMenus();		
	}
 
	public void clicMenu(String codeMenuClique) {
		activerChargement(codeMenuClique);
		panneauCentre.removeAll();
		if (codeMenuClique.equals(MenuApplicationId.STRUCTURE)) {
			modele.selectionnerStructure(panneauCentre, getProjetId(), null);
		} else if (codeMenuClique.equals(MenuApplicationId.PUBLICATION)) {
			modele.selectionnerPublications(panneauCentre);
		} else if (codeMenuClique.equals(MenuApplicationId.PERSONNE)) { 
			modele.selectionnerPersonne(panneauCentre, null, getProjetId(), null);
		} else {
			GWT.log("Non implémenté! Menu id : "+codeMenuClique, null);
		}
		panneauCentre.layout();
	}
	
	public void activerChargement(String message) {
		afficherPopinChargement(); 
		panneauSud.showBusy(i18nC.chargement()+" "+message);
	}
	
	public void desactiverChargement() {
		masquerPopinChargement();
		panneauSud.clear();
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES FENÊTRES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void ouvrirAide() {
		AideFenetre aideFenetre = new AideFenetre();
		aideFenetre.show();
		// FIXME : apparament le fade In/Fade Out pose problème sur les navigateurs...
		//aideFenetre.el().fadeIn(FxConfig.NONE);
	}
 
	public void ouvrirParametres() {
		ParametreFenetre parametresFenetre = new ParametreFenetre();
		parametresFenetre.show();
	}
 
	public void ouvrirIdentification() {
		fenetreIdentification = new IdentificationFenetre();
		fenetreIdentification.show();
	}
 
	public void ouvrirApplis(String id) {
		if (id.equals(ComposantId.MENU_CEL)) {
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getCelUrl(), "Carnet en ligne", "");
		} else if (id.equals(ComposantId.MENU_BEL)) {
			Window.open(((Configuration) Registry.get(RegistreId.CONFIG)).getCelUrl(), "Biblio en ligne", "");
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION de l'UTILISATEUR et de l'IDENTIFICATION
	//+----------------------------------------------------------------------------------------------------------------+
	/**
	 * Retourne l'identifiant de l'utilisateur courrant de l'application.
	 */
	public String getUtilisateurId() {
		String id = null;
		Utilisateur utilisateurCourant = (Utilisateur) Registry.get(RegistreId.UTILISATEUR_COURANT);
		if (!utilisateurCourant.getId().equals("")) {
			id = utilisateurCourant.getId();
		}
		return id;
	}
	
	public void connecterUtilisateur(String login, String mdp) {
		modele.connecterUtilisateur(this, login, mdp);
	}
	
	public void deconnecterUtilisateur() {
		modele.deconnecterUtilisateur(this);
	}
	
	public void mettreAJourEtatIdentification(Utilisateur utilisateur) {
		// Mise à jour du registre
		Registry.register(RegistreId.UTILISATEUR_COURANT, utilisateur);
		// Création de l'information de mise à jour de l'utilisateur
		Information info = new Information("maj_utilisateur");
 
		// Rafraichissement de la fenêtre d'Identification
		if (fenetreIdentification != null) {
			fenetreIdentification.rafraichir(info);
		}
		
		// Rafraichissement du panneau Nord
		panneauNord.rafraichir(info);
 
		// Rafraichissement du panneau Centre
		if (contenuPanneauCentre != null) {
			contenuPanneauCentre.rafraichir(info);
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES PERSONNES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void clicListePersonne(Personne personne)	{
		((PersonneDetailPanneauVue) Registry.get(RegistreId.PANNEAU_PERSONNE_DETAIL)).rafraichir(personne);
		
	}
 
	public void afficherListePersonnes(PersonneListe personnesACharger)	{
		if ( !(contenuPanneauCentre instanceof PersonneVue) ) {
			PersonneVue personneVue = new PersonneVue();
			contenuPanneauCentre = personneVue;
			panneauCentre.add(personneVue);
		}
		contenuPanneauCentre.rafraichir(personnesACharger);
		//contenuPanneauCentre.layout();
	}
 
	public void clicAjouterPersonne()	{
		
		afficherPopinChargement();
		 
		panneauCentre.removeAll();
		FormPersonneVue formulairePersonneVue = new FormPersonneVue();
		contenuPanneauCentre = formulairePersonneVue;
		panneauCentre.add(formulairePersonneVue);
		panneauCentre.layout();
	}
	
	public void clicModifierPersonne(Personne personne)	{
		if (personne!=null)	{
			panneauCentre.removeAll();
			FormPersonneVue formulairePersonneVue = new FormPersonneVue();
			contenuPanneauCentre = formulairePersonneVue;
			panneauCentre.add(formulairePersonneVue);
			
			selectionnerPersonne(formulairePersonneVue, personne);
			
			panneauCentre.layout();			
			
 
		}
	}
	
	public void selectionnerPersonne(Rafraichissable vue, Personne personne)	{
		modele.selectionnerPersonne(vue, personne.getId(), null, null);
	}
	
	public void clicSupprimerPersonne(final Rafraichissable vue,final List<Personne> personneSelection) {
		
		String ids = "" ;
		
		if (personneSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une personne.");
		} else if(personneSelection.size() > 0) {
			String message = "Êtes vous sur de vouloir supprimer les personnes sélectionnées ?";
			if (personneSelection.size() == 1) {
				message = "Êtes vous sur de vouloir supprimer la personne sélectionnée ?";
			}
			
			
			final Listener listenerSuppression = new Listener<ComponentEvent>() { 
				
				public void handleEvent(ComponentEvent ce) {
					Dialog dialog = (Dialog) ce.component;
					Button btn = dialog.getButtonPressed();  
 
					if (btn.getText().equals(dialog.yesText)) {
						String idStr = "" ;
						Iterator<Personne> itPersonne = personneSelection.iterator();
						while (itPersonne.hasNext()) {
							Personne personneCourante = itPersonne.next();
							idStr += personneCourante.getId();
 
 
							idStr +=",";
						}
 
						modele.supprimerPersonne(vue, idStr);  
					}
				}
			};
				     
			MessageBox.confirm("Supprimer une personne", message, listenerSuppression);
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerPersonne() du Médiateur.");
		}
	}
 
	public void selectionnerPersonneParNomComplet(Rafraichissable vue, String projetId, String nomComplet) {
		modele.selectionnerPersonne(vue, null, projetId, nomComplet);
	}
	
	public void enregistrerPersonne(Rafraichissable vue, Personne personne){
			modele.enregistrerPersonne(vue, personne);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES VALEURS ET LISTES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void afficherListeValeurs(ValeurListe nouvelleDonnees) {
		if (panneauCentre.getId().equals(ComposantId.PANNEAU_STRUCTURE_FORM)) {
			((FormStructureVue) panneauCentre.getItem(0)).rafraichir(nouvelleDonnees);
		} else {
			GWT.log("Aucun panneau trouvé pour afficher la liste de valeur", null);
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES PUBLICATIONS
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void afficherListePublication(PublicationListe nouvelleDonnees) {
		PublicationVue publicationVue = new PublicationVue() ;
		panneauCentre.removeAll();
		panneauCentre.add(publicationVue);
		contenuPanneauCentre = publicationVue;
		publicationVue.rafraichir(nouvelleDonnees);
		
	}
 
	public void clicListePublication(Publication publication) {
		panneauCentre.rafraichir(publication);	
	}
 
	public void clicAjouterPublication() {
		panneauCentre.removeAll();
		FormPublicationVue formPublicationVue = new FormPublicationVue();
		panneauCentre.add(formPublicationVue);
		panneauCentre.setId(ComposantId.PANNEAU_FORM_PUBLICATION);
		panneauCentre.layout();
	}
	
	public void clicModifierPublication(List<Publication> publicationListe) {
		if(publicationListe.size() <= 0) {
			MessageBox.alert("Attention", "Vous devez sélectionner une publication", null);
		} else {
			Publication pubAModifier = publicationListe.get(publicationListe.size() -1);
			panneauCentre.removeAll();
			FormPublicationVue formPublicationVue = new FormPublicationVue();
			panneauCentre.add(formPublicationVue);
			panneauCentre.setId(ComposantId.PANNEAU_FORM_PUBLICATION);
			panneauCentre.layout();
			formPublicationVue.rafraichir(pubAModifier);
		}
	}
	
	public void clicSupprimerPublication(final List<Publication> publicationListe) {
		if(publicationListe.size() <= 0) {
			MessageBox.alert("Attention", "Vous devez sélectionner une publication", null); 
		} else {
			String message = "" ;
			if(publicationListe.size() == 1) {
				message = "Voulez-vous vraiment supprimer cette publication ?";
			}
			else {
				message = "Voulez-vous vraiment supprimer ces publication ?";
			}
			
			
			final Listener listenerSuppression = new Listener<ComponentEvent>() { 
				public void handleEvent(ComponentEvent ce) {  
				    	   
					Dialog dialog = (Dialog) ce.component;
				    Button btn = dialog.getButtonPressed();  
				    	   
				    if (btn.getText().equals(dialog.yesText)) {
				    	modele.supprimerPublication(contenuPanneauCentre, getUtilisateurId(),publicationListe);  
				    }
				}
			};
				     
			MessageBox.confirm("Supprimer une publication", message, listenerSuppression);
		}
		
	}
 
	public void ajouterPublication(FormPublicationVue formPublicationVue, Publication publi) {
		modele.ajouterPublication(contenuPanneauCentre, getUtilisateurId(),publi);
	}
	
	public void modifierPublication(FormPublicationVue formPublicationVue, Publication publi) {
		modele.modifierPublication(contenuPanneauCentre, getUtilisateurId(),publi);
	}
 
	public void clicObtenirListeEditeurs(Rafraichissable vue) {
		modele.selectionnerStructure(vue, null, null);
	}
 
	public void clicObtenirListeAuteurs(Rafraichissable vue) {
		modele.selectionnerPersonne(vue, null, null, null);
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION DES STRUCTURES
	//+----------------------------------------------------------------------------------------------------------------+
 
	public void clicListeStructure(Structure structure) {
		contenuPanneauCentre.rafraichir(structure);
		if (structure.getPersonnel() == null) {
			selectionnerStructureAPersonne(contenuPanneauCentre, structure.getId(), StructureAPersonne.ROLE_EQUIPE);
		} else {
			GWT.log("OK personnel déjà chargé", null);
		}
	}
 
	public void afficherListeStructures(StructureListe structuresACharger) {
		// TODO : créer dès l'initialisation de l'application InsitutionVue et la cacher
		StructureVue institutionVue = new StructureVue(this);
		panneauCentre.add(institutionVue);
		panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_LISTE);
		contenuPanneauCentre = institutionVue;
		institutionVue.rafraichir(structuresACharger);
	}
	
	public void clicAjouterStructure() {
		panneauCentre.removeAll();
		FormStructureVue formStructureVue = new FormStructureVue(FormStructureVue.MODE_AJOUTER);
		panneauCentre.add(formStructureVue);
		panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_FORM);
		panneauCentre.layout();
	}
	
	public void clicModifierStructure(List<Structure> structureSelection) {
		if (structureSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une structure.");
		} else if (structureSelection.size() > 1) {
			Info.display("Information", "Veuillez sélectionner une seule structure à la fois.");
		} else if (structureSelection.size() == 1) {
			panneauCentre.removeAll();
			FormStructureVue formStructureVue = new FormStructureVue(FormStructureVue.MODE_MODIFIER);
			panneauCentre.add(formStructureVue);
			panneauCentre.setId(ComposantId.PANNEAU_STRUCTURE_FORM);
			
			selectionnerStructure(formStructureVue, structureSelection.get(0).getId());
			selectionnerStructureAPersonne(formStructureVue, structureSelection.get(0).getId(), StructureAPersonne.ROLE_EQUIPE);
			
			panneauCentre.layout();
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicModifierStructure() du Médiateur.");
		}
		
	}
	
	public void clicSupprimerStructure(final Rafraichissable vue, final List<Structure> structureSelection) {
		if (structureSelection.size() == 0) {
			Info.display("Information", "Veuillez sélectionner une structure.");
		} else if(structureSelection.size() > 0) {
			String message = "Êtes vous sur de vouloir supprimer les structures sélectionnées ?";
			if (structureSelection.size() == 1) {
				message = "Êtes vous sur de vouloir supprimer la structure sélectionnée ?";
			}
			
			
			final Listener listenerSuppression = new Listener<ComponentEvent>() { 
				
			       public void handleEvent(ComponentEvent ce) {  
			    	   
			    	   Dialog dialog = (Dialog) ce.component;
			    	   Button btn = dialog.getButtonPressed();  
			    	   
			    	   if (btn.getText().equals(dialog.yesText))	{
			    		   	String idStr = "" ;
							for(int i = 0 ; i < structureSelection.size() ; i++) {
								idStr += structureSelection.get(i).getId()+"," ; 
							}
							modele.supprimerStructure(vue, getUtilisateurId(), idStr); 
					       }
				      }
				     };
				     
			MessageBox.confirm("Supprimer une structure", message, listenerSuppression);
			
		} else {
			Info.display("Erreur", "Une erreur est survenue dans la méthode clicSupprimerStructure() du Médiateur.");
		}
	}
	
	public void selectionnerStructure(Rafraichissable vue, String structureId) {
		GWT.log("Structure : "+structureId, null);
		modele.selectionnerStructure(vue, null, structureId);
	}
	
	/**
	 * TODO : afficher un message du type "Structure ajoutée".  
	 * Lance la creation d'une structure
	 * @param les données de la structure saisie
	 */
	public void ajouterStructure(Rafraichissable vue, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
		modele.ajouterStructure(vue, getUtilisateurId(), structure, conservation, valorisation);
	}
	
	public void modifierStructure(Rafraichissable vue, String structureId, Structure structure, StructureConservation conservation, StructureValorisation valorisation) {
		modele.modifierStructure(vue, getUtilisateurId(), structureId, structure, conservation, valorisation);
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	// GESTION de la relation STRUCTURE A PERSONNE
	public void selectionnerStructureAPersonne(Rafraichissable vue, String structureId, String roleId) {
		GWT.log("Structure : "+structureId, null);
		modele.selectionnerStructureAPersonne(vue, getUtilisateurId(), null, structureId, roleId);
	}
	
	public void modifierStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelModifie) {
		if (personnelModifie != null && personnelModifie.size() > 0) {
			GWT.log("Mediateur :modif", null);
			for (Iterator<String> it = personnelModifie.keySet().iterator(); it.hasNext();) {
				modele.modifierStructureAPersonne(vue, getUtilisateurId(), (StructureAPersonne) personnelModifie.get(it.next()));
			}
		}
	}
	
	public void ajouterStructureAPersonne(Rafraichissable vue, String structureId, StructureAPersonneListe personnelAjoute) {
		if (personnelAjoute != null && personnelAjoute.size() > 0) {
			for (Iterator<String> it = personnelAjoute.keySet().iterator(); it.hasNext();) {
				modele.ajouterStructureAPersonne(vue, getUtilisateurId(), structureId, (StructureAPersonne) personnelAjoute.get(it.next()));
			}
		}
	}
	
	public void supprimerStructureAPersonne(Rafraichissable vue, StructureAPersonneListe personnelSupprime) {
		if (personnelSupprime != null && personnelSupprime.size() > 0) {
			String idStrAPer = "" ;
			for (Iterator<String> it = personnelSupprime.keySet().iterator(); it.hasNext();) {
					idStrAPer += personnelSupprime.get(it.next()).getId()+"," ;
			}
			modele.supprimerStructureAPersonne(vue, getUtilisateurId(), idStrAPer);
		}
	}
 
	//+----------------------------------------------------------------------------------------------------------------+
	//												GESTION des PROJETS
	//+----------------------------------------------------------------------------------------------------------------+
	
	/**
	 * Retourne l'identifiant du projet courrant de l'application.
	 */
	public String getProjetId() {
		String id = null;
		Projet projetCourant = (Projet) Registry.get(RegistreId.PROJET_COURANT);
		if (projetCourant != null && !projetCourant.getId().equals("")) {
			id = projetCourant.getId();
		}
		return id;
	}
	
	//Greg : ajout d'un écouteur pour le changement liste projet
	public void selectionnerProjets(Rafraichissable vue)	{
		modele.selectionnerProjets(vue);
	}
	
	public void afficherListeProjets(ProjetListe projets)	{
		panneauOuest.rafraichir(projets);
	}
	
	public void selectionnerProjetCourant(Projet projetSelectionne) {
		Registry.register(RegistreId.PROJET_COURANT, projetSelectionne);
		if (contenuPanneauCentre instanceof PersonneVue)	{
			modele.selectionnerPersonne(contenuPanneauCentre, null, getProjetId(), null);
			//FIXME Le rafraichissement du panneau ne se fait pas!
		} else if (contenuPanneauCentre instanceof StructureVue)	{
			modele.obtenirListeStructures(contenuPanneauCentre, getProjetId());
		}
	}
	
	//+----------------------------------------------------------------------------------------------------------------+
	//	RAFRAICHISSEMENT
	//+----------------------------------------------------------------------------------------------------------------+
	
	public void rafraichir(Object nouvelleDonnees) {
		if (nouvelleDonnees instanceof Utilisateur) {
			mettreAJourEtatIdentification((Utilisateur) nouvelleDonnees);
		} else {
			GWT.log("Pas de correspondance dans la méthode rafraichir() de la classe "+this.getClass(), null);
		}
	}
	
	/**
	 * Récupère la liste et rafraichit la vue donnée
	 * 
	 * @param la vue à rafraichir
	 * @param l'id de la liste à récupérer
	 * */
	public void obtenirListeValeurEtRafraichir(Rafraichissable vue, String listeId)	{
		modele.obtenirListeValeurs(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId));
	}
	
	public void obtenirValeurEtRafraichir(Rafraichissable vue, String listeId, String identifiantValeur)	{
		modele.obtenirValeur(vue, "abv", ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(listeId), identifiantValeur);
	}
	
	public void obtenirListeRegionsEtRafraichir(Rafraichissable vue, String strListeId, String strPays)	{
		modele.obtenirListeRegion(vue, ((Configuration) Registry.get(RegistreId.CONFIG)).getListeId(strListeId), strPays+".__");
	}
	
	/**
	 * 	Affiche la popin de chargement
	 */
	public void afficherPopinChargement()	{
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).center();
	}
	
	
	public void masquerPopinChargement()	{		
		((PopupChargement) Registry.get(RegistreId.POPUP_CHARGEMENT)).hide();
	}
}

Subversion Repositories eFlore/Applications.coel

(root)/trunk/src/org/tela_botanica/client/Mediateur.java @ 1333 – Rev 379 → 389

Rev 379		Rev 389
1	`package org.tela_botanica.client;`	1	`package org.tela_botanica.client;`
2		2
3	`import java.util.Iterator;`	3	`import java.util.Iterator;`
4	`import java.util.List;`	4	`import java.util.List;`
5		5
6	`import org.tela_botanica.client.composants.AideFenetre;`	6	`import org.tela_botanica.client.composants.AideFenetre;`
7	`import org.tela_botanica.client.composants.IdentificationFenetre;`	7	`import org.tela_botanica.client.composants.IdentificationFenetre;`
8	`import org.tela_botanica.client.composants.ParametreFenetre;`	8	`import org.tela_botanica.client.composants.ParametreFenetre;`
9	`import org.tela_botanica.client.i18n.Constantes;`	9	`import org.tela_botanica.client.i18n.Constantes;`
10	`import org.tela_botanica.client.interfaces.Rafraichissable;`	10	`import org.tela_botanica.client.interfaces.Rafraichissable;`
11	`import org.tela_botanica.client.modeles.Configuration;`	11	`import org.tela_botanica.client.modeles.Configuration;`
12	`import org.tela_botanica.client.modeles.Information;`	12	`import org.tela_botanica.client.modeles.Information;`
13	`import org.tela_botanica.client.modeles.MenuApplicationId;`	13	`import org.tela_botanica.client.modeles.MenuApplicationId;`
14	`import org.tela_botanica.client.modeles.Personne;`	14	`import org.tela_botanica.client.modeles.Personne;`
15	`import org.tela_botanica.client.modeles.PersonneListe;`	15	`import org.tela_botanica.client.modeles.PersonneListe;`
16	`import org.tela_botanica.client.modeles.Projet;`	16	`import org.tela_botanica.client.modeles.Projet;`
17	`import org.tela_botanica.client.modeles.ProjetListe;`	17	`import org.tela_botanica.client.modeles.ProjetListe;`
18	`import org.tela_botanica.client.modeles.Publication;`	18	`import org.tela_botanica.client.modeles.Publication;`
19	`import org.tela_botanica.client.modeles.PublicationListe;`	19	`import org.tela_botanica.client.modeles.PublicationListe;`
20	`import org.tela_botanica.client.modeles.Structure;`	20	`import org.tela_botanica.client.modeles.Structure;`
21	`import org.tela_botanica.client.modeles.StructureAPersonne;`	21	`import org.tela_botanica.client.modeles.StructureAPersonne;`
22	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`	22	`import org.tela_botanica.client.modeles.StructureAPersonneListe;`
23	`import org.tela_botanica.client.modeles.StructureConservation;`	23	`import org.tela_botanica.client.modeles.StructureConservation;`
24	`import org.tela_botanica.client.modeles.StructureListe;`	24	`import org.tela_botanica.client.modeles.StructureListe;`
25	`import org.tela_botanica.client.modeles.StructureValorisation;`	25	`import org.tela_botanica.client.modeles.StructureValorisation;`
26	`import org.tela_botanica.client.modeles.Utilisateur;`	26	`import org.tela_botanica.client.modeles.Utilisateur;`
27	`import org.tela_botanica.client.modeles.ValeurListe;`	27	`import org.tela_botanica.client.modeles.ValeurListe;`
28	`import org.tela_botanica.client.vues.ContenuPanneauVue;`	28	`import org.tela_botanica.client.vues.ContenuPanneauVue;`
29	`import org.tela_botanica.client.vues.EntetePanneauVue;`	29	`import org.tela_botanica.client.vues.EntetePanneauVue;`
30	`import org.tela_botanica.client.vues.FormPersonneVue;`	30	`import org.tela_botanica.client.vues.FormPersonneVue;`
31	`import org.tela_botanica.client.vues.FormPublicationVue;`	31	`import org.tela_botanica.client.vues.FormPublicationVue;`
32	`import org.tela_botanica.client.vues.FormStructureVue;`	32	`import org.tela_botanica.client.vues.FormStructureVue;`
33	`import org.tela_botanica.client.vues.PersonneDetailPanneauVue;`	33	`import org.tela_botanica.client.vues.PersonneDetailPanneauVue;`
34	`import org.tela_botanica.client.vues.PersonneVue;`	34	`import org.tela_botanica.client.vues.PersonneVue;`
35	`import org.tela_botanica.client.vues.PopupChargement;`	35	`import org.tela_botanica.client.vues.PopupChargement;`
36	`import org.tela_botanica.client.vues.PublicationDetailPanneauVue;`	36	`import org.tela_botanica.client.vues.PublicationDetailPanneauVue;`
37	`import org.tela_botanica.client.vues.PublicationVue;`	37	`import org.tela_botanica.client.vues.PublicationVue;`
38	`import org.tela_botanica.client.vues.StatutPanneauVue;`	38	`import org.tela_botanica.client.vues.StatutPanneauVue;`
39	`import org.tela_botanica.client.vues.StructureDetailPanneauVue;`	39	`import org.tela_botanica.client.vues.StructureDetailPanneauVue;`
40	`import org.tela_botanica.client.vues.StructureVue;`	40	`import org.tela_botanica.client.vues.StructureVue;`