Subversion Repositories eFlore/Applications.cel

Rev

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

package org.tela_botanica.client.observation;



// TODO : systematiser les onQuelquechose, appelle depuis les vues
import org.tela_botanica.client.CarnetEnLigneMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation;
import org.tela_botanica.client.modeles.objets.InfosReferentielNom;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels;
import org.tela_botanica.client.vues.observation.CartographieObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireImportObservationVue;
import org.tela_botanica.client.vues.observation.FormulaireSaisieObservationVue;
import org.tela_botanica.client.vues.observation.ListeObservationVue;
import org.tela_botanica.client.vues.observation.MenuObservationVue;
import org.tela_botanica.client.vues.observation.PanneauFiltresObservationVues;
import org.tela_botanica.client.vues.observation.indicateurs.ImageGeneriqueVue;
import org.tela_botanica.client.vues.observation.indicateurs.InformationRepartitionVue;
import org.tela_botanica.client.vues.observation.indicateurs.LienExterneVue;
import org.tela_botanica.client.vues.observation.indicateurs.MiniZoomImageVue;

import com.google.gwt.core.client.GWT;
import com.google.gwt.maps.client.geom.LatLng;
import com.google.gwt.user.client.History;
import com.google.gwt.user.client.Window;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.core.RegionPosition;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.Tree;
import com.gwtext.client.dd.DragData;
import com.gwtext.client.widgets.BoxComponent;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.layout.BorderLayout;
import com.gwtext.client.widgets.layout.BorderLayoutData;
import com.gwtext.client.widgets.layout.FitLayout;
import com.gwtext.client.widgets.layout.RowLayout;
import com.gwtext.client.widgets.layout.RowLayoutData;
import com.gwtext.client.widgets.tree.TreeNode;


/**
 * Mediateur gérant les interactions entre vues et les echanges de données
 * C'est un singleton. 
 * @author aurelien
 *
 */
public class ObservationMediateur {
        
        /**
         * booleen qui verifie l'unicite de l'instance (donc static)
         */
        private static boolean estInstancie = false ;

        /**
         * pointeur sur le médiateur (pour le pattern singleton)
         */
        private static ObservationMediateur thisMediateur = null ;  
        
        /** Mediateur general de l'application carnet en ligne
         * 
         * 
         */
        private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
        
        
        /**
         * modele de données
         */
        private ObservationModele observationModele = null ;
        
        
        /**
         * panneau principal des Observation (onglet "observation")
         */
        private final Panel panneauPrincipalObservation = new Panel("Observations");
        
        
        /**
         * liste détaillée des Observations
         */
        public ListeObservationVue listeObservation = null ;
        
        /**
         * Saisie des Observations
         */
        
        private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
        
        
        /**
         * 
         * Import des observations depuis un fichier
         * 
         */
        
        private FormulaireImportObservationVue formImportObs=null;
        
        
        /**
         * Cartographie
         */
        private CartographieObservationVue cartoObservationVue = null;
        
        

        /**
         * booleen explicitant s'il y a une selection en cours
         */
        private boolean selection = false ;             
        /**
         * panneau conteneur pour le panneau  des informations lies à l'observation
         */
        
        private Panel details = new Panel("Details");

        private LienExterneVue liExtVue = null;

        /**
         * panneau conteneur pour le panneau des filtres
         */
        
        private PanneauFiltresObservationVues filtres = null;

        
        
        /** 
         * panneau d'information de repartition sur le nom selectionné 
         * 
         */
        
        private InformationRepartitionVue informationRepartitionVue=null;
        
        
        /** 
         * panneau d'affichage d'une image generique associe au nom selectionne 
         * 
         */
        
        private ImageGeneriqueVue imageGeneriqueVue=null;
        
        private MiniZoomImageVue mvz = null ;
        
        private boolean importerObservations = false ;

        private com.gwtext.client.widgets.Window fenetreCarto;
        public boolean changementTabProg = false;
        
        private InfosReferentielNom refTaxSelectionne = null;

        private Panel centre;
        
        /**
         * constructeur privé (on accède a la classe par la méthode getInstance
         */
        
        
        private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
        {
                this.carnetEnLigneMediateur=carnetEnLigneMediateur;                                     
                // on crée un modèle
                observationModele = ObservationModele.Instance(this);
                
                // initialisation du référentiel par défaut
                setRefTaxSelectionne(Configuration.getReferentielsDispos().get(0));     
        
                listeObservation = new ListeObservationVue(this);
                listeObservation.setTitle("Observations");
                
                // quelques variables de position pour les borderlayouts
                final BorderLayoutData regionNord = new BorderLayoutData(
                                RegionPosition.NORTH);

                final BorderLayoutData regionCentre = new BorderLayoutData(
                                RegionPosition.CENTER);
                regionCentre.setSplit(true);

                  
                final BorderLayoutData regionEst = new BorderLayoutData(
                                RegionPosition.EAST);
                regionEst.setSplit(true);
        

                final BorderLayoutData regionOuest = new BorderLayoutData(
                                RegionPosition.WEST);
                regionOuest.setSplit(true);
                
                
                panneauPrincipalObservation.setLayout(new BorderLayout()) ;
                cartoObservationVue = new CartographieObservationVue(this);
                cartoObservationVue.setLayout(new FitLayout());
                
                // Le formulaire de saisie / modification d'observation
                formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
                formulaireSaisieObservationVue.setTitle("Saisie");
                formulaireSaisieObservationVue.setTitleCollapse(true);
                formulaireSaisieObservationVue.setCollapsible(true) ;
                formulaireSaisieObservationVue.setAutoScroll(true) ;
                
                fenetreCarto = new com.gwtext.client.widgets.Window();
                fenetreCarto.setConstrain(true);
                fenetreCarto.setModal(true);
                
                fenetreCarto.add(cartoObservationVue);
                
                formulaireSaisieObservationVue.addListener(
                new PanelListenerAdapter() {
                        @Override
                        public void onCollapse(Panel panel)  {
                                CarnetEnLigneMediateur.fireResize();
                        }
                    @Override
                        public void onExpand(Panel panel) {
                        CarnetEnLigneMediateur.fireResize();
                    }
                });
                
                centre = new Panel();
                centre.setLayout(new BorderLayout());
                centre.setAutoScroll(true);
                centre.setBorder(false);
                
                centre.addListener(
                        new PanelListenerAdapter() {
                                @Override
                                public void onCollapse(Panel panel)  {
                                        CarnetEnLigneMediateur.fireResize();
                                }
                            @Override
                                public void onExpand(Panel panel) {
                                CarnetEnLigneMediateur.fireResize();
                            }
                            
                                @Override
                                public void onResize(BoxComponent component, int adjWidth,
                                                int adjHeight, int rawWidth, int rawHeight) {
                                        formulaireSaisieObservationVue.redimensionnerFormulaire();
                                        listeObservation.doLayout();
                                }
                                
                                @Override
                                public void onAfterLayout(Container self) {
                                        
                                }
                });
                
                formulaireSaisieObservationVue.setBorder(false);
                
                BorderLayoutData listeLayoutData = new BorderLayoutData(RegionPosition.SOUTH);
                listeLayoutData.setSplit(true);
                
                BorderLayoutData formLayoutData = new BorderLayoutData(RegionPosition.CENTER);
                formLayoutData.setSplit(true);
                
                centre.add(listeObservation, listeLayoutData);
                centre.add(formulaireSaisieObservationVue, formLayoutData);

                // Redimensionnement global sur collapse/expand
                details.addListener(
                        new PanelListenerAdapter() {
                                @Override
                                public void onCollapse(Panel panel)  {
                                        CarnetEnLigneMediateur.fireResize();
                                }
                            @Override
                                public void onExpand(Panel panel) {
                                        
                                String[] selectionListe = listeObservation.getIdSelectionnees();
                                if(selectionListe.length > 0) {
                                        Observation obs = listeObservation.getCacheListeObservation().get(selectionListe[0]);
                                        obtenirImageInformationExternes(obs.getCodeCourtReferentielTaxo(), obs.getNumeroNomenclaturalSaisi());
                                }
                                CarnetEnLigneMediateur.fireResize();
                            }
                });
                                        
                // on initialise le volet qui contient les details
                details.setWidth("10%");
                details.setTitleCollapse(true);
                details.setCollapsible(true);
                
                details.setAutoScroll(true);
                details.setLayout(new RowLayout());
                
                // Lien vers eflore
                liExtVue = new LienExterneVue(this);
                liExtVue.setHeight("20px");
                details.add(liExtVue);
                
                // Information de repartition
                informationRepartitionVue=new InformationRepartitionVue(this);
                details.add(informationRepartitionVue, new RowLayoutData("30%"));
                
                // Image generique
                imageGeneriqueVue=new ImageGeneriqueVue(this);
                details.add(imageGeneriqueVue, new RowLayoutData("30%"));
                
                mvz = new MiniZoomImageVue(this) ; 
                
                details.add(mvz, new RowLayoutData("34%")) ;    
                
                // on crée le panneau des filtres
                filtres = new PanneauFiltresObservationVues(this);
                
                // on initialise le volet qui contient les filtres
                filtres.setWidth("10%");
                filtres.setTitleCollapse(true);
                filtres.setCollapsible(true);
                
                
                filtres.addListener(
                        new PanelListenerAdapter() {
                                @Override
                                public void onCollapse(Panel panel)  {
                                        CarnetEnLigneMediateur.fireResize();
                                }
                            @Override
                                public void onExpand(Panel panel) {
                                CarnetEnLigneMediateur.fireResize();
                            }
                });
                
                panneauPrincipalObservation.add(details,regionEst);
                
                panneauPrincipalObservation.add(filtres,regionOuest);
                panneauPrincipalObservation.add(centre,regionCentre);
        }
        
        /**
         * Retourne une instance de manière unique
         * @return l'instance unique du médiateur
         */
        public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
        {
                        if(!estInstancie || thisMediateur == null)
                        {
                                estInstancie = true ;
                                thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
                        }
                        
                        return thisMediateur ;  
        }
        
        
        public void connecterUtilisateur() {
                
                if(importerObservations) {
                        observationModele.importerObservations();
                }
                
                if(panneauPrincipalObservation == null || !panneauPrincipalObservation.isCreated()) 
                {
                        panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
                        {
                                @Override
                                public void onRender(Component c)
                                {
                                        panneauPrincipalObservation.purgeListeners() ;
                                        initialiserArbres();
                                        filtres.getRechercheLibreVue().raz();
                                        obtenirNombreObservation();
                                        analyserHistorique();
                                }
                        }) ;
                }
                else
                {
                        initialiserArbres();
                        filtres.getRechercheLibreVue().raz();
                        obtenirNombreObservation();
                        analyserHistorique();
                }
        }
        
        private void initialiserArbres() {
                getPanneauFiltres().getArbreDateObservationFiltreVue().initialiser();
                getPanneauFiltres().getArbreEntiteGeographiqueObservationFiltreVue().initialiser();             
                getPanneauFiltres().getArbreMotsClesObservationVue().initialiser();     
        }

        
        
        // ACTIONS  a entreprendre lors d'un evenement particulier 
        /**
         * Lors du raffraichissement de la liste d'observation  
         */
        public void onRafraichissementListeObservations() {
                
                carnetEnLigneMediateur.donneesObsVersImages(listeObservation.getCacheListeObservation());
                observationModele.rafraichirCacheObservation(listeObservation.getCacheListeObservation());
                
                filtres.getArbreMotsClesObservationVue().cocherMotsCles(new String[0]);
        }
        
        /**
         * 
         * TODO : fonction plus generique, appelle sur un clic ou une selection de ligne, a appeller : SelectionnerObservation 
         * est appelé lors d'un clic de souris sur un enregistrement de la liste le
         * médiateur gère alors les conséquences
         * 
         * @param rowIndex
         *            le numéro de ligne selectionné
         */
        
        public void onClicListeObservation(int rowIndex, String ordreObservation) {
        
                Observation obs = obtenirCacheObservation().get(ordreObservation) ;
                
                if(GWT.isScript()) {
                        masquerChargementInfosObservations() ;
                }
                
                gererMiseAJourFormulaireObservation();
                gererMiseAJourPanneauDetails(obs);      
        }
        
        public void gererMiseAJourPanneauDetails(Observation obs) {
                // Affichage de l'image correspondante
                if(details.isVisible()) {
                        // Affichage de la carte de repartition correspondante
                        String numeroNomenclaturalSaisiObservation = obs.getNumeroNomenclaturalRetenu();
                        if(numeroNomenclaturalSaisiObservation != null && !numeroNomenclaturalSaisiObservation.isEmpty()) {
                                observationModele.obtenirImageInformationRepartition(informationRepartitionVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
                                observationModele.obtenirImageGenerique(imageGeneriqueVue,obs.getCodeCourtReferentielTaxo(), numeroNomenclaturalSaisiObservation) ;
                        } else {
                                informationRepartitionVue.rafraichir("", false);
                                imageGeneriqueVue.rafraichir("", false);
                        }
                        observationModele.obtenirLiaisonImage(mvz, obs.getId()) ;
                        liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
                }
                filtres.getArbreMotsClesObservationVue().rafraichir(obs.getMotsCles(), false);
        }
        
        public void gererMiseAJourFormulaireObservation() {
                String[] ids = listeObservation.getIdSelectionnees();
                if(ids.length == 1) {
                        Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length - 1]);
                        // affichage des détails dans le formulaire d'observation
                        formulaireSaisieObservationVue.rafraichir(obs, false) ;
                } else {
                        ListeObservation listeObs = new ListeObservation();
                        for(int i=0; i < ids.length;i++) {
                                Observation obsAjout = observationModele.getCacheObservation().get(ids[i]);
                                listeObs.ajouterObservation(obsAjout);
                        }
                        formulaireSaisieObservationVue.rafraichir(listeObs, false);
                }
        }
        
        public void obtenirImageInformationExternes(String referentielTaxo, String numeroNomenclaturalSaisiObservation) {
                
                if(details.isVisible()) {
                        if(GWT.isScript()) {
                                masquerChargementInfosObservations() ;
                        }
                        liExtVue.rafraichir(numeroNomenclaturalSaisiObservation, false);
                        observationModele.obtenirImageInformationRepartition(informationRepartitionVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
                        observationModele.obtenirImageGenerique(imageGeneriqueVue, referentielTaxo, numeroNomenclaturalSaisiObservation) ;
                }
        }
        
        public int getTaillePage() {
                return listeObservation.getTaillePage();
        }
        
        public int getPageEnCours() {
                return listeObservation.getPageEncours();
        }
        
        
        // ACCES au Modèle 
        // C du CRUD 
        /**
         * TODO : afficher un message du type "observation ajouté".  
         * Lance la creation d'une observation
         * @param obs : l'observation saisie
         */     
        public void ajouterObservation(Observation obs) {
          // On rafraichit la liste d'observation 
          observationModele.ajouterObservation(listeObservation, obs) ;
          filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
          filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
                
        }
        
        // R du CRUD 
        /**
         * Demande au modele le nombre d'Observation à afficher
         * TODO : grouper cette demande avec la demande d'affichage de liste ? 
         */

        public void obtenirNombreObservation() {
                
                listeObservation.masquerChargement() ;
                mvz.raz() ;
                imageGeneriqueVue.raz() ;
                informationRepartitionVue.raz() ;
                
                observationModele.obtenirNombreObservation(listeObservation) ;
                
        }
        
        /**
         * Demande au modele le nombre d'Observation à afficher
         * TODO : grouper cette demande avec la demande d'affichage de liste ? 
         */

        public void obtenirDernierePageObservation() {
                
                listeObservation.rafraichir(new Observation(),false) ;
                
        }

        
        
        public void obtenirListeObservation() {
                obtenirListeObservation(listeObservation);
        }
        
        /**
         * Demande au modele le detail  des Observations à afficher
         * TODO : grouper cette demande avec la demande d'affichage de liste ? 
         */

        
        public void obtenirListeObservation(Rafraichissable r) {
                
                listeObservation.masquerChargement() ;
                observationModele.obtenirListeObservation(r,listeObservation.getTaillePage(),listeObservation.getPageEncours()) ;
        }
        
        public void obtenirCacheObservation(Rafraichissable r) {
                
                r.rafraichir(observationModele.getCacheObservation(), false) ;
        }
        

        /**
         * Envoie au modèle une demande pour obtenir l'arbre des localites
         * 
         * @param r
         *            le raffraichissable qui a demandé la mise à jour
         */
        public void obtenirListeEntiteGeographique() {
                
                observationModele.obtenirListeEntiteGeographique(filtres.getArbreEntiteGeographiqueObservationFiltreVue());
                
        }
        
        
        // U du CRUD
        public void modifierObservation(Observation obs) {
                
                // On prend soin de récupérer les mots clés de l'observation
                Observation obsMod = obtenirCacheObservation().get(obs.getNumeroOrdre());
                obs.setMotsCles(obsMod.getMotsCles());
                
                // On rafraichit la liste d'observation
                observationModele.modifierObservation(listeObservation, obs) ;
                filtres.getArbreEntiteGeographiqueObservationFiltreVue().rafraichir(obs,true) ;
                filtres.getArbreDateObservationFiltreVue().rafraichir(obs,true) ;
                
        }
        
        public void modifierObservationEnMasse(Observation obs) {
                // On rafraichit la liste d'observation
                listeObservation.masquerChargement();
                observationModele.modifierObservationEnMasse(listeObservation, obs) ;
        }
        
        // D du CRUD
        /**
         * TODO : afficher un message du type "observation modifie".  
         * Lance la modification d'une observation
         * @param obs : l'observation a modifier
         */
        
        
        
        public void supprimerObservation(Rafraichissable r, String numeroOrdre) {
                
                if(listeObservation.getSelectionModel().getCount() > 0)
                {
                        if(Window.confirm("Êtes vous sur de vouloir supprimer cette observation ?")) {
                        observationModele.supprimerObservation(r,numeroOrdre) ;
                        }
                }
                
        }
        
        public boolean listeAvoirObservations() {
                return listeObservation.getStore().getCount() > 0;
        }
        
        // Assistants de saisie
        /**
         *  
         * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne 
         * @param r : la vue demandeuse de donnee
         * @param critere : les criteres de selection
         */
        
        public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
                
                observationModele.obtenirListeReferentielCommune(r,critere) ;
        }
        
        // Assistants de saisie
        /**
         *  
         * Lance un appel de recherche d'une liste de résultats 
         * correspondant aux criteres de selections pour un référentiel donné 
         * @param r : la vue demandeuse de donnee
         * @param referentiel : le référentiel demandé
         * @param critere : les criteres de selection
         */
        public void obtenirListeReferentielPerso(Rafraichissable r, TypesReferentiels referentiel, String critere) {
                observationModele.obtenirListeReferentielPerso(r, referentiel, critere) ;
        }
        
        /**
         *  
         * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne 
         * @param r : la vue demandeuse de donnee
         * @param critere : les criteres de selection
         */
        
        public void obtenirListeReferentielNom(Rafraichissable r,String referentiel, String critere) {

                observationModele.obtenirListeReferentielNom(r, referentiel, critere) ;         
        }
        
        // Etat du syteme
        
        /**
         * C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
         * sous forme de tableau [nom, valeur]
         * @return Les noms et valeurs des filtres
         */
        public String[][] renvoyerFiltres()
        {               
                int longueur = 0;
                
                String[] filtresEntitesGeo = filtres.getArbreEntiteGeographiqueObservationFiltreVue().renvoyerValeursAFiltrer() ;
                String chaineNomsFiltresGeo = filtresEntitesGeo[0] ;
                String chaineValFiltresGeo = filtresEntitesGeo[1] ;
                
                String[] filtresDate = filtres.getArbreDateObservationFiltreVue().renvoyerValeursAFiltrer() ;
                String chaineNomsFiltresDate = filtresDate[0] ;
                String chaineValFiltresDate = filtresDate[1] ;
                
                String[] filtresTaxon = filtres.getRechercheLibreVue().renvoyerValeursAFiltrer();
                
                String[] filtresMotsCles = filtres.getArbreMotsClesObservationVue().renvoyerValeursAFiltrer();
                
                String chaineNomsFiltres = "" ;
                String chaineValFiltres = "" ;
                
                if(!chaineNomsFiltresGeo.trim().equals("") && !chaineValFiltresGeo.trim().equals("")) {
                        chaineNomsFiltres += chaineNomsFiltresGeo+",";
                        chaineValFiltres += chaineValFiltresGeo+",";
                }
                
                if(!chaineNomsFiltresDate.trim().equals("") && !chaineValFiltresDate.trim().equals("")) {
                        chaineNomsFiltres += chaineNomsFiltresDate+",";
                        chaineValFiltres += chaineValFiltresDate+",";
                }
                
                if(!filtresTaxon[0].trim().equals("") && !filtresTaxon[1].trim().equals("")) {
                        chaineNomsFiltres += filtresTaxon[0]+",";
                        chaineValFiltres += filtresTaxon[1]+",";
                }
                
                if(!filtresMotsCles[0].trim().equals("") && !filtresMotsCles[1].trim().equals("")) {
                        chaineNomsFiltres += filtresMotsCles[0];
                        chaineValFiltres += filtresMotsCles[1];
                }
                
                String[] nomsFiltres = chaineNomsFiltres.split(",") ;
                String[] valsFiltres = chaineValFiltres.split(",") ;
                
                longueur += nomsFiltres.length;
                
                String [][] valeursFiltres = new String[longueur][2] ;
                
                int i = 0;
                
                if(valsFiltres.length > 0)
                {
                        for(i = 0 ; i < nomsFiltres.length ; i++)
                        {
                                valeursFiltres[i][0] = nomsFiltres[i] ;
                                if(valsFiltres[i].equals("Inconnue")) 
                                {
                                        valeursFiltres[i][1] = "NULL" ;
                                }
                                else
                                {
                                        valeursFiltres[i][1] = valsFiltres[i] ;
                                }
                        }
                }
                
                listeObservation.afficherFiltres(valeursFiltres) ;
                
                return valeursFiltres ;
        }

        /**
         * 
         * @return
         * 
         */
        
        public Panel getPanneauPrincipalObservation() {
                return panneauPrincipalObservation;
        }


        public void montrerContextMenu(EventObject e) {
                
                MenuObservationVue mvo = new MenuObservationVue(this) ;
                mvo.showAt(e.getXY()) ;
                
        }

        public void doubleClicListeObservation(int rowIndex) {
                
                
        }
        
        // Getters 
        
        public PanneauFiltresObservationVues getPanneauFiltres() {
                
                return filtres;
                
        }
        
        public void masquerChargementInfosObservations()
        {
                ExtElement masked = Ext.get(details.getId());

                if (details.isVisible() && masked != null) {
                        informationRepartitionVue.raz() ;
                        imageGeneriqueVue.raz() ;
                        masked.mask("Chargement", true);
                }

                cartoObservationVue.masquerChargement(true);
        }
        
        public void deMasquerChargementInfosObservations()
        {
                ExtElement masked = Ext.get(details.getId());

                if (details.isVisible() && masked != null) {
                        masked.unmask() ;
                }       
        }


        public void obtenirDatesObservation() {
                
                observationModele.obtenirDatesObservation(filtres.getArbreDateObservationFiltreVue()) ;
        }


        public void exporterObservations() {
                
                        observationModele.exporterObservations() ;
        }

        public void exporterObservationsPDF() {
                if(listeObservation.getIdSelectionnees().length > 300) {
                        // com.google.gwt.user.client
                        Window.alert("Les étiquettes ne peuvent être générées pour plus de 300 observations d'un coup.");
                        return;
                }
                // TODO: nombre en fonction des filtres actifs, combien d'éléments seraient envoyés ?
                if(listeObservation.getIdSelectionnees().length == 0) {
                        //import com.google.gwt.core.client.GWT.log( XXX éléments);
                }
                observationModele.exporterObservationsPDF(listeObservation.getIdSelectionnees());
        }


        public void deconnecterUtilisateur() {
                
                if(panneauPrincipalObservation == null || panneauPrincipalObservation.isCreated() || !panneauPrincipalObservation.isVisible())
                {
                        panneauPrincipalObservation.addListener(new ContainerListenerAdapter()
                        {
                                @Override
                                public void onShow(Component component)
                                {
                                        deconnecterUtilisateur();
                                        panneauPrincipalObservation.purgeListeners();
                                }
                        });
                }
                else
                {
                        listeObservation.raz() ;
                        formulaireSaisieObservationVue.raz() ;
                        razFiltres();
                        informationRepartitionVue.raz() ;
                        imageGeneriqueVue.raz() ;
                        mvz.raz() ;
                }
        }


        public void supprimerLiaisonObsImage() {
                
                String ordreObs = listeObservation.getIdSelectionnees()[0];
                String idObs = observationModele.getIdPourOrdreObs(ordreObs);
                String idImg = mvz.getIdImage() ;
                
                if(Window.confirm("Supprimer le lien entre l'image "+idImg+" et l'observations "+idObs+" ?"))
                {
                        mvz.supprimerLiaisonImage() ;
                        observationModele.supprimerLiaisonImages(idImg,idObs) ;
                }
                
        }

        public void supprimerObservations() {
                
                if(listeObservation.getIdSelectionnees().length > 0) {
                        if(Window.confirm("Êtes vous sur de vouloir supprimer les observations sélectionnées ?")) { 
                                        String[] numObs = listeObservation.getIdSelectionnees();
                                        String numObsapl = "" ;
                                        for(int i = 0 ; i < numObs.length ; i++) {
                                                numObsapl += numObs[i]+"," ; 
                                        }
                                        
                                        observationModele.supprimerListeObservation(listeObservation,numObsapl) ;
                        }
                }
                else
                {
                        Window.alert("Aucune observation sélectionnée");
                }
        }


        public void transmettreObservations(boolean publier) {
                
                if(Utilisateur.getInstance().isIdentifie()) {
                        if(listeObservation.getIdSelectionnees().length > 0) {
                                
                                String action = "" ;
                                
                                if(publier) {
                                        action = "rendre publiques" ;
                                }
                                else {
                                        action = "rendre privées" ;
                                }
                                
                                if(Window.confirm("Êtes vous sur de vouloir "+action+" les observations sélectionnées ?")) { 
                                        String[] numObs = listeObservation.getIdSelectionnees();
                                        String numObsApl = "" ;
                                        for(int i = 0 ; i < numObs.length ; i++) {
                                                numObsApl += numObs[i] ;
                                                if(i != numObs.length - 1) {
                                                        numObsApl +="," ;
                                                }
                                        }
                                        
                                        observationModele.transmettreListeObservation(listeObservation,numObsApl, publier) ;
                                }
                        }
                        else
                        {
                                Window.alert("Aucune observation sélectionnée");
                        }
                }
                else
                {
                        if(publier) {
                                if(Window.confirm("La publication des observations nécessite d'être identifié, voulez-vous vous identifier ? (toutes vos observations saisies seront conservées)")) {
                                        importerObservations = true ;
                                        carnetEnLigneMediateur.afficherDialogueConnexion();
                                }
                        }
                }
                
        }
        
        public void analyserHistorique() {
                
                if (History.getToken().length()>0) {

                final String anum=History.getToken();
                observationModele.analyserHistorique(formulaireSaisieObservationVue,anum);
                }
        }

        /**
         * Appelle le modèle pour mettre à jour la paire mot-clé / identifiant du
         * mot clé
         * 
         * @param text
         *            le texte du mot clé
         * @param id
         *            l'identifiant du mot clé
         */
        public void mettreAjourMotsClesId(String text, String id) {

                observationModele.mettreAjourMotsClesId(text, id);

        }
        
        public boolean gererDDObsSurMotCle(TreeNode NoeudMotCle, DragData dragData) {
                
                if(dragData instanceof GridDragData) {

                        GridDragData gdd = ((GridDragData)dragData);
                        
                        String idMotCle = ((String[])NoeudMotCle.getUserObject())[1];
                        
                        Record[] obsALier = gdd.getSelections();
                        
                        String idObsALier[] = new String[obsALier.length];
                        String idObsALierString = "";
                        
                        for(int i = 0; i < obsALier.length; i++) {
                                if(i != 0) {
                                        idObsALierString += ", ";
                                }
                                idObsALierString += obsALier[i].getAsString("ordre_observation");
                                
                                if(!observationAvoirMotCle(idMotCle, obsALier[i].getAsString("ordre_observation"))) {
                                        idObsALier[i] = obsALier[i].getAsString("ordre_observation");
                                } else {
                                        idObsALier[i] = "";
                                }
                        }
                        
                        String message = "Lier les observations "; 
                        
                        if(idObsALier.length == 1) {
                                message = "Lier l'observation "; 
                        }
                        
                        if(Window.confirm(message+idObsALierString+" au projet "+NoeudMotCle.getText()+" ?")) {
                                mettreAjourMotsCles(idMotCle, idObsALier);
                                
                                return true;
                        } else {
                                return false;
                        }
                } else {
                        return false;
                }
        }
        
        public void gererDDMotCleSurObs(String idObs, String idMC) {
                
                Observation obs = obtenirCacheObservation().get(idObs);
                
                if(obs == null) {
                        return;
                }
                
                if(observationAvoirMotCle(idMC, idObs)) {
                        if(Window.confirm("Voulez vous supprimer la liaison entre l'observation et le mot clé ?")) {
                                String nouveauMotsCles = obs.getMotsCles().replace(idMC, "");
                                nouveauMotsCles = nouveauMotsCles.replace(";;", ";");
                                
                                obs.setMotsCles(nouveauMotsCles);
                                
                                observationModele.supprimerLiaisonMotCleObservations(listeObservation, obs.getId(), idMC);
                        }
                }
        }

        public String gererOverDDMotCleSurObs(String idObs, String IdMC) {
                
                if(observationAvoirMotCle(IdMC, idObs)) {
                    return "x-dd-drop-unlink";
                } else {
                        return "x-dd-drop-nodrop";
                }
        }
        /**
         * Récupère les identifiants des obs selectionnézs et appelle le modèle
         * pour qu'il mette à jour les associations mots clés/obs
         * 
         * @param motsClesEnCours
         *            les mots clés à associer aux images selectionnés séparés par
         *            un ';'
         * @param arbreMC
         *            l'arbre des mots clés à mettre à jour
         */
        public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) {
                
                String[] ids = listeObservation.getIdSelectionnees();
                observationModele.mettreAjourMotsCles(motsClesEnCours, idsObsALier);

        }

        /**
         * Appelle le médiateur pour qu'il ajoute un mot clé dans l'arbre des mots
         * clés
         * 
         * @param n
         *            le noeud à ajouter à l'arbre
         * @param arbreMC
         *            le nouvel arbre de mots clés à mettre à jour
         */
        public void ajouterMotCleDansArbre(TreeNode n, Tree arbreMC) {
                observationModele.ajouterMotCleDansArbre(n, arbreMC);
                getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false);

        }

        /**
         * Appelle le médiateur pour qu'il supprime un mot clé et son sous arbre
         * dans l'arbre des mots clés
         * 
         * @param n
         *            le noeud à supprimer
         * @param arbreMC
         *            le nouvel arbre de mots clés à mettre à jour
         */
        public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {

                observationModele.supprimerMotCleDansArbre(n, arbreMC);
                getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n.getId(), false);

        }

        /**
         * Appelle le médiateur pour qu'il modifie un mot clé dans l'arbre des mots
         * clés
         * 
         * @param n
         *            le noeud à modifier
         * @param arbreMC
         *            le nouvel arbre de mots clés à mettre à jour
         */
        public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {

                observationModele.modifierMotCleDansArbre(n, arbreMC);
                getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(n, false);

        }

        /**
         * Appelle le médiateur pour qu'il déplace un mot clé et son sous arbre dans
         * l'arbre des mots clés
         * 
         * @param n
         *            le noeud à déplacer
         * @param arbreMC
         *            le nouvel arbre de mots clés à mettre à jour
         */
        public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {

                observationModele.deplacerMotCleDansArbre(n, arbreMC);
        }


        public void rafraichirArbreMotsCles(Tree arbreMotsCles) {
                
                getPanneauFiltres().getArbreMotsClesObservationVue().rafraichir(arbreMotsCles, false);
                
        }
        
        public boolean observationAvoirMotCle(String idMotCle, String idObs) {
                Observation obs = obtenirCacheObservation().get(idObs);
                if(obs == null) {
                        return false;
                }
                
                if(obs.getMotsCles().contains(idMotCle)) {
                        return true;
                }
                
                return false;
        }


        public void obtenirArbreMotsCles(Rafraichissable r) {
                
                observationModele.obtenirArbreMotsCles(r);
        }
        
        public String[] obtenirTexteMotsCles(String[] idsMotsCles) {
                
                String[] tableauMotsClesTexte = new String[idsMotsCles.length];
                
                for(int i=0; i< idsMotsCles.length; i++) {
                        tableauMotsClesTexte[i] = observationModele.obtenirTexteMotCle(idsMotsCles[i]);
                }
                
                return tableauMotsClesTexte;
        }
        
        public ListeObservation obtenirCacheObservation() {
                return observationModele.getCacheObservation();
        }

        public void donneesExterieures(Object nouvelleDonnees) {
                if(nouvelleDonnees instanceof Tree) {
                        
                        Tree arbreMotsCles = (Tree)nouvelleDonnees ;
                        observationModele.rafraichirArbreMotsCles(nouvelleDonnees);
                        rafraichirArbreMotsCles(arbreMotsCles);
                }
        }
        
        public void transmettreDonnees(Object o) {
                carnetEnLigneMediateur.donneesObsVersImages(o);
        }
        
        public void obtenirInformationCoord(Rafraichissable r, LatLng coord) {
                observationModele.obtenirInformationCoord(r,coord);
        }
        
        public void obtenirInformationCommune(Rafraichissable r, String nomCommune, String codePostal) {
                observationModele.obtenirInformationCommune(r,nomCommune, codePostal);
        }

        public void obtenirInformationCoord(LatLng coord) {
                observationModele.obtenirInformationCoord(cartoObservationVue,coord);
        }

        public void obtenirInformationCommune(String nomCommune,
                        String codePostal) {
                observationModele.obtenirInformationCommune(cartoObservationVue,nomCommune, codePostal);
        }

        public void rafraichirSaisieCommuneObservation(EntiteGeographiqueObservation infosCommune) {
                formulaireSaisieObservationVue.rafraichir(infosCommune, false);
                cacherFenetreCarto();
        }

        private void razFiltres() {
                filtres.getArbreDateObservationFiltreVue().raz() ;
                filtres.getArbreEntiteGeographiqueObservationFiltreVue().raz() ;
                filtres.getArbreMotsClesObservationVue().raz();
                filtres.getRechercheLibreVue().raz();
        }
        

        public void viderFiltre(String nom) {
                filtres.viderFiltres(nom);
                obtenirNombreObservation();
        }

        public Component getListeObservation() {
                return listeObservation;
        }

        public void redimensionnerPanneaux(int adjHeight, int adjWidth) {       
                formulaireSaisieObservationVue.setHeight(300);
                listeObservation.setHeight(adjHeight/2);
                centre.doLayout();
        }

        public void afficherFormulaireImportObservation() {
                if (formImportObs==null) { // lazy inst. 
                        formImportObs = new FormulaireImportObservationVue(this);
                }
                formImportObs.afficher();       
        }

        public void setImporterObservationsAnonymes(boolean importerObservations) {
                this.importerObservations = importerObservations;
        }
        

        private void localiserSurCommuneSelectionnee() {
                
                cartoObservationVue.masquerChargement(true);
                
                double[] coordsTab = formulaireSaisieObservationVue.coordonneesValides();
                
                if(formulaireSaisieObservationVue.coordonneesValides() != null && !formulaireSaisieObservationVue.getCommune().equals("")) {
                        
                        String nomCommune = formulaireSaisieObservationVue.getCommuneSansDepartement();
                        String dptCommune = formulaireSaisieObservationVue.getDepartement();
                        EntiteGeographiqueObservation egeo = new EntiteGeographiqueObservation(dptCommune, nomCommune, "","");
                        egeo.setLat(coordsTab[0]+"");
                        egeo.setLon(coordsTab[1]+"");
                        
                        cartoObservationVue.rafraichir(egeo, false);
                        
                } else {        
                        if(formulaireSaisieObservationVue.coordonneesValides() != null) {
                                LatLng coords = LatLng.newInstance(coordsTab[0],coordsTab[1]);
                                obtenirInformationCoord(coords);
                        } else if (formulaireSaisieObservationVue.communeInitialisee()) {
                                String nomCommune = formulaireSaisieObservationVue.getCommune();
                                String dptCommune = formulaireSaisieObservationVue.getDepartement();
                                obtenirInformationCommune(nomCommune, dptCommune);
                        } else {
                                obtenirInformationCoord(cartoObservationVue.getCentreFrance());
                        }
                }
        }

        public void afficherFenetreCarto() {
                int hauteur = (int)Math.round(Window.getClientHeight()*0.75);
                int largeur = (int)Math.round(Window.getClientWidth()*0.75);
                fenetreCarto.setSize(largeur, hauteur);
                if(!fenetreCarto.isVisible()) {
                        fenetreCarto.show();
                }
                cartoObservationVue.setTailleCarte(hauteur - 20, largeur - 20);
                cartoObservationVue.recentrerCarte();
        }
        
        

        private void cacherFenetreCarto() {
                if(fenetreCarto.isVisible()) {
                        fenetreCarto.hide();
                }
        }

        public InfosReferentielNom getRefTaxSelectionne() {
                return refTaxSelectionne;
        }
        
        public void setRefTaxSelectionne(int index) {
                refTaxSelectionne = Configuration.getReferentielsDispos().get(index);
        }
        
        public void setRefTaxSelectionne(InfosReferentielNom refTax) {
                refTaxSelectionne = refTax;
        }
}