Subversion Repositories eFlore/Applications.cel

Rev

Rev 217 | Rev 235 | 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.ListeObservation;
import org.tela_botanica.client.modeles.Observation;
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.filtres.ArbreMotsClesObservationVue;
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.MiniZoomImageVue;
import org.tela_botanica.client.vues.observation.indicateurs.NuageMotsClesVue;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
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.widgets.Component;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.event.PanelListener;
import com.gwtext.client.widgets.event.PanelListenerAdapter;
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.menu.BaseItem;
import com.gwtext.client.widgets.menu.Item;
import com.gwtext.client.widgets.menu.Menu;
import com.gwtext.client.widgets.menu.event.MenuListenerAdapter;
import com.gwtext.client.widgets.tree.TreeEditor;
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
         */
        private ListeObservationVue listeObservation = null ;
        
        /**
         * Saisie des Observations
         */
        
        private FormulaireSaisieObservationVue formulaireSaisieObservationVue=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("Détails");

        private Panel panelMotsCles = new Panel("Mots Clés");
        
        private ArbreMotsClesObservationVue arbreMotsClesVue = null ;
        
        private TabPanel detailsEtMotsCles = new TabPanel();


        /**
         * 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 NuageMotsClesVue nuaMC = null;
        
        private Panel conteneurFormulaire = null ;
        
        private boolean importerObservations = false ;
        
        /**
         * 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);
                
        
                listeObservation = new ListeObservationVue(this);
                listeObservation.setTitle("Observations");
                
                listeObservation.addListener(
                                new PanelListenerAdapter() {
                                                        public void onCollapse(Panel panel)  {
                                                                ObservationMediateur.fireResize();
                                                        }
                                                    public void onExpand(Panel panel) {
                                                        ObservationMediateur.fireResize();
                                                    }
                });
                                
                
                // quelques variables de position pour les borderlayouts
                final BorderLayoutData regionNord = new BorderLayoutData(
                                RegionPosition.NORTH);

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

                  
                final BorderLayoutData regionEst = new BorderLayoutData(
                                RegionPosition.EAST);
        
                        
                if (GWT.isScript()) {  // FIXME : ne fonctionne pas en mode hosted
                        regionEst.setSplit(true);
                }

                final BorderLayoutData regionOuest = new BorderLayoutData(
                                RegionPosition.WEST);
                
                if (GWT.isScript()) {  // FIXME : ne fonctionne pas en mode hosted                      
                        regionOuest.setSplit(true);
                }
                
                panneauPrincipalObservation.setLayout(new BorderLayout()) ;
                
                // on ajoute un panneau supplémentaire pour contenir le formulaire, pour éviter un bug de taille
                // des panneaux
                conteneurFormulaire = new Panel();
                
                // Le formulaire de saisie / modification d'observation
                formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
                formulaireSaisieObservationVue.setHeader(false);
                conteneurFormulaire.setTitle("Saisie");
                conteneurFormulaire.setTitleCollapse(true);
                conteneurFormulaire.setCollapsible(true) ;
                conteneurFormulaire.setAutoScroll(true) ;
                // Redimensionnement global sur collapse/expand
                conteneurFormulaire.addListener(
                new PanelListenerAdapter() {
                                        public void onCollapse(Panel panel)  {
                                                ObservationMediateur.fireResize();
                                        }
                                    public void onExpand(Panel panel) {
                                        ObservationMediateur.fireResize();
                                    }
                });
                
                
                
                
                final Panel centre = new Panel();
                centre.setLayout(new RowLayout());
                centre.setAutoScroll(true);
                centre.setBorder(false);
                
                formulaireSaisieObservationVue.setBorder(false);
                conteneurFormulaire.add(formulaireSaisieObservationVue);
                
                centre.add(conteneurFormulaire, new RowLayoutData("40%"));
                centre.add(listeObservation, new RowLayoutData("60%"));
                
                Panel conteneurDetailsMotsCles = new Panel("Détails");

                // Redimensionnement global sur collapse/expand
                conteneurDetailsMotsCles.addListener(
                new PanelListenerAdapter() {
                                        public void onCollapse(Panel panel)  {
                                                ObservationMediateur.fireResize();
                                        }
                                    public void onExpand(Panel panel) {
                                        ObservationMediateur.fireResize();
                                    }
                });
                
                
                                
                // on initialise le volet qui contient les details
                conteneurDetailsMotsCles.setWidth("10%");
                conteneurDetailsMotsCles.setTitleCollapse(true);
                conteneurDetailsMotsCles.setCollapsible(true);
                
                conteneurDetailsMotsCles.add(detailsEtMotsCles);
                
                conteneurDetailsMotsCles.setLayout(new FitLayout());
                
                
                details.setAutoScroll(true);
                details.setLayout(new RowLayout());
                details.setWidth("100%");
                
                arbreMotsClesVue = new ArbreMotsClesObservationVue(this) ;
                panelMotsCles.add(arbreMotsClesVue);
                
                // Information de repartition
                informationRepartitionVue=new InformationRepartitionVue(this);
                details.add(informationRepartitionVue, new RowLayoutData("33%"));
                
                
                // Image generique
                imageGeneriqueVue=new ImageGeneriqueVue(this);
                details.add(imageGeneriqueVue, new RowLayoutData("33%"));
                
                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() {
                                                        public void onCollapse(Panel panel)  {
                                                                ObservationMediateur.fireResize();
                                                        }
                                                    public void onExpand(Panel panel) {
                                                        ObservationMediateur.fireResize();
                                                    }
                });
                                
                
                detailsEtMotsCles.add(details);
                //detailsEtMotsCles.add(panelMotsCles);
                
                panelMotsCles.hide();
                
                
                panneauPrincipalObservation.add(conteneurDetailsMotsCles,regionEst);
                
        
                
                panneauPrincipalObservation.add(filtres,regionOuest);
                panneauPrincipalObservation.add(centre,regionCentre);
                
        }

        public static native void fireResize() /*-{
                 $wnd.Ext.EventManager.fireResize();
        }-*/;
        
        
        /**
         * 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()
                        {
                                public void onRender(Component c)
                                {
                                        panneauPrincipalObservation.purgeListeners() ;
                                        obtenirNombreObservation();
                                        initialiserArbres();
                                        analyserHistorique();
                                }
                                
                        }) ;
                }
                else
                {
                        obtenirNombreObservation();
                        initialiserArbres();
                        analyserHistorique();
                }
        }
        
        private void initialiserArbres() {
                getPanneauFiltres().getArbreDateObservationFiltreVue().initialiser();
                getPanneauFiltres().getArbreEntiteGeographiqueObservationFiltreVue().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());
        }
        
        /**
         * 
         * 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() ;
                }
                
                // Affichage de la carte de repartition correspondante
                String numeroNomenclaturalSaisiObservation = obs.getNumeroNomenclaturalSaisi() ;
                
                observationModele.obtenirImageInformationRepartition(informationRepartitionVue,numeroNomenclaturalSaisiObservation) ;
                
                if(formulaireSaisieObservationVue.getModification()) {
                        String[] ids = listeObservation.getIdSelectionnees();
                        if(ids.length > 1) {
                                formulaireSaisieObservationVue.setMasseModification(true);
                                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);
                        } else {
                                formulaireSaisieObservationVue.setMasseModification(false);
                                // affichage des détails dans le formulaire d'observation
                                formulaireSaisieObservationVue.rafraichir(obs, false) ;
                        }
                } else {
                        formulaireSaisieObservationVue.rafraichir(obs, false) ;
                }
                // Affichage de l'image correspondante
                                
                observationModele.obtenirImageGenerique(imageGeneriqueVue,numeroNomenclaturalSaisiObservation) ;
                
                observationModele.obtenirLiaisonImage(mvz, ordreObservation) ;
                
                observationModele.obtenirMotsClesId(arbreMotsClesVue, ordreObservation);
                //arbreMotsClesVue.cocherMotsCles(motsClesIds);


        }
        
        public void obtenirImageInformationExternes(String numeroNomenclaturalSaisiObservation) {
                if(GWT.isScript()) {
                        masquerChargementInfosObservations() ;
                }
                observationModele.obtenirImageInformationRepartition(informationRepartitionVue,numeroNomenclaturalSaisiObservation) ;
                observationModele.obtenirImageGenerique(imageGeneriqueVue,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 raffraichi 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) ;
                
        }

        
        
        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 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) ;
                        }
                }
                
        }
        
        // 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) ;

                
        }
        
        
        
        /**
         *  
         * 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 critere) {

                observationModele.obtenirListeReferentielNom(r,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[] filtresMotsCles = filtres.getArbreMotsClesFiltreVue().renvoyerValeursAFiltrer();
                        if(filtresMotsCles.length > 0) {
                                longueur++ ;
                        }*/
                
                        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 chaineNomsFiltres = chaineNomsFiltresGeo+","+chaineNomsFiltresDate ;
                        String chaineValFiltres = chaineValFiltresGeo+","+chaineValFiltresDate ;
                        
                        String[] nomsFiltres = chaineNomsFiltres.split(",") ;
                        String[] valsFiltres = chaineValFiltres.split(",") ;
                        
                        longueur += nomsFiltres.length;
                        
                        String [][] valeursFiltres = new String[longueur][2] ;
                        
                        listeObservation.afficherFiltres(chaineValFiltresGeo, chaineValFiltresDate) ;

                        int i = 0;
                        
                        if(nomsFiltres.length > 0)
                        {
                                for(i = 0 ; i < nomsFiltres.length ; i++)
                                {
                                        valeursFiltres[i][0] = nomsFiltres[i] ;
                                        if(valsFiltres[i].equals("Inconnue")) 
                                        {
                                                valeursFiltres[i][1] = "000null" ;
                                        }
                                        else
                                        {
                                                valeursFiltres[i][1] = valsFiltres[i] ;
                                        }
                                }
                        }
                        
                        /*if(filtresMotsCles.length > 0) {
                                valeursFiltres[i][0] = filtresMotsCles[0] ;
                                filtresMotsCles[1] = filtresMotsCles[1].replace("\n", " ");
                                valeursFiltres[i][1] = filtresMotsCles[1].replace(" ", ";") ;
                        }*/
                        
                        return valeursFiltres ;
        }

        
        /**
         * Retourne l'identifiant de l'utilisateur connecte
         * @return : identifiant de l'utilisateur connecte
         */
        public String getIdentifiant() {
                
                return carnetEnLigneMediateur.getUtilisateur().getIdentite();
        
        }


        /**
         * 
         * @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(detailsEtMotsCles.getId());

                if (details.isVisible() && masked != null && !masked.isMasked()) {
                        informationRepartitionVue.raz() ;
                        imageGeneriqueVue.raz() ;
                        masked.mask("Chargement", true);
                }
        }
        
        public void deMasquerChargementInfosObservations()
        {
                ExtElement masked = Ext.get(detailsEtMotsCles.getId());

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


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


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


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


        public void supprimerLiaisonObsImage() {
                
                String idObs = listeObservation.getIdSelectionnees()[0] ;
                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(carnetEnLigneMediateur.getUtilisateur().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);
                }
        }


        public void montrerContextMenuArbre(final TreeNode n, EventObject e,
                        TreeEditor te) {
                        Menu mn = new Menu();
                        final com.gwtext.client.widgets.menu.Item ajoutN = new Item(
                                        "Ajouter mot cle");
                        final com.gwtext.client.widgets.menu.Item suppN = new Item(
                                        "Supprimer mot cle");

                        mn.addItem(ajoutN);
                        mn.addItem(suppN);

                        mn.addListener(new MenuListenerAdapter() {

                                public void onItemClick(BaseItem item, EventObject e) {
                                        if (item.equals(suppN)) {
                                                arbreMotsClesVue
                                                                .supprimerNoeud(n);
                                        }
                                        if (item.equals(ajoutN)) {
                                                arbreMotsClesVue.ajouterNoeud(
                                                                n);
                                        }
                                }
                        });

                        mn.showAt(e.getXY());
                
        }


        /**
         * 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);

        }

        /**
         * Récupère les identifiants des images selectionnés et appelle le modèle
         * pour qu'il mette à jour les associations mots clés/images
         * 
         * @param motsClesEnCours
         *            les mots clés à associer aux images selectionnés séparés par
         *            une ','
         * @param arbreMC
         *            l'arbre des mots clés à mettre à jour
         */
        public void mettreAjourMotsCles(String motsClesEnCours, Tree arbreMC) {

                String[] ids = listeObservation.getIdSelectionnees();
                observationModele.mettreAjourMotsCles(ids, motsClesEnCours, arbreMC);

        }

        /**
         * 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().getArbreMotsClesFiltreVue().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().getArbreMotsClesFiltreVue().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().getArbreMotsClesFiltreVue().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);
                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(n, false);
        }


        public void rafraichirArbreMotsCles(Tree arbreMotsCles) {
                
                arbreMotsClesVue.rafraichir(arbreMotsCles, false);
                getPanneauFiltres().getArbreMotsClesFiltreVue().rafraichir(arbreMotsCles, false);
                
        }


        public void obtenirArbreMotsCles(Rafraichissable r) {
                
                observationModele.obtenirArbreMotsCles(r);
        }
        
        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 onModeModification() {
                
                String[] ids = listeObservation.getIdSelectionnees();
                Observation obs = listeObservation.getCacheListeObservation().get(ids[ids.length]);
                if(ids.length > 1) {
                        formulaireSaisieObservationVue.setMasseModification(true);
                        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);
                } else {
                        formulaireSaisieObservationVue.setMasseModification(false);
                        // affichage des détails dans le formulaire d'observation
                        formulaireSaisieObservationVue.rafraichir(obs, false) ;
                }
        }
}