Subversion Repositories eFlore/Archives.cel-v2

package org.tela_botanica.client.vues;


import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import org.tela_botanica.client.vues.BarrePaginationObservationVue;

import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.RowSelectionModel;
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;

/**
 * Liste d'observation composée de ligne d'observation
 * l'interface rafraichissable et l'interface vueListable
 * 
 * @author David Delon 2008
 */
public class ListeObservationVue extends GridPanel implements Rafraichissable,
                VueListable {

        /**
         * Le médiateur associé à la vue
         */
        private ObservationMediateur    observationMediateur            = null;


        /**
         * Config de colonne
         */
        private ColumnConfig    etatObservation;
        /**
         * Config de colonne
         */
        private ColumnConfig    nomSaisiObservation;
        /**
         * Config de colonne
         */
        private ColumnConfig    nomRetenuObservation;
        /**
         * Config de colonne
         */
        private ColumnConfig    lieuObservation;
        /**
         * Config de colonne
         */
        private ColumnConfig    dateObservation;
        /**
         * Config de colonne
         */
        private ColumnConfig    ordreObservation;
        /**
         * Modele de colonnes
         */
        private ColumnModel             modeleColonnes;

        /**
         * Store qui contient les données à afficher
         */
        private Store                   st                              = null;
        
        
        /**
         * Barre de pagination
         */
        private BarrePaginationObservationVue bt = null ;

        /**
         * Constructeur sans arguments (privé car ne doit pas être utilisé)
         */
        private ListeObservationVue()
        {
                super() ;
        }
        
        /**
         * Constructeur avec argument
         * @param im le médiateur à associer
         */
        public ListeObservationVue(ObservationMediateur obs) {          
                
                this.observationMediateur = obs;
                
                setHeader(true);
                setTitle("Observations");
        
                // on place la barre de pagination
                bt = new BarrePaginationObservationVue(observationMediateur);           
                this.setBottomToolbar(bt) ;

                // on construit le modèle de colonnes

                // Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) 
                                
                
                etatObservation = new ColumnConfig("Transmis", "etat_observation", 50);         
                nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200);
                nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200);
                lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200);
                dateObservation = new ColumnConfig("Date", "date_observation", 70);
                ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50);
                
                
        
                // on associe le modèle de colonnes
                
                ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation};
                
                modeleColonnes = new ColumnModel(cm);
                
                this.setColumnModel(modeleColonnes);
                
                this.setAutoScroll(true);
                this.setAutoWidth(true);
                this.setEnableColumnResize(true);

            // FIXME: ca ne devrait pas ête obligatoire de fixer la taille 
                 
                this.setSize(800,400);
                
                // creation du store
                FieldDef defEtatObservation = new StringFieldDef("etat_observation");
                FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
                FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
                FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
                FieldDef defDateObservation = new StringFieldDef("date_observation");
                FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
                
                
                FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
                                defLieuObservation, defDateObservation, defOrdreObservation };
                
                RecordDef rd = new RecordDef(defTab);
                st = new Store(rd);
                
                // on associe le store
                
                this.setStore(st);
                this.getView().setAutoFill(true);
                
                // on crée un masque de chargement qui s'affichera lors des mises à jour
                this.setLoadMask("Chargement");
        
                // on ajoute les listeners
                ajouterListeners();
                
                
        }


        /**
         * Ajoute les listeners pour la gestion des évènements
         */
        private void ajouterListeners() {
                this.addListener(new ContainerListenerAdapter() {

                        
                        public void onHide(Component component) {

                        }

                        
                        public void onRender(Component component) {
                                
                        }

                        
                        public void onShow(Component component) {

                        }

                });

/*              
                this.addGridRowListener(new GridRowListener() {
                        
                        // gestion du clic sur une ligne
                        public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {

                                // on notifie le médiateur et on lui passe le nuémro de ligne
                                getobservationMediateur().clicListeImage(rowIndex);
                        }
                        
                        // gestion du clic droit
                        public void onRowContextMenu(GridPanel grid, int rowIndex,
                                        EventObject e) {
                                // on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
                                e.stopEvent() ;
                                // on notifie le médiateur en lui passant l'évenement
                                getobservationMediateur().montrerContextMenu(e);
                        }

                        // gestion du double clic
                        public void onRowDblClick(GridPanel grid, int rowIndex,
                                        EventObject e) {
                                // on notifie le médiateur en lui passant le numéro de ligne
                                getobservationMediateur().doubleClicListeImage(rowIndex);
                        }
                });
                
        */
                this.getSelectionModel().addListener(new RowSelectionListenerAdapter() {

                        // gestion de la sélection
                        
                        public void onSelectionChange(RowSelectionModel sm) {

                                // si on a rien de sélectionné
                                if (sm.getCount() <= 0) {
                                        // on notifie le médiateur (qui désactive notamment l'accès à certaines infos)
                //                      getobservationMediateur().aucuneSelection();
                                } else {
                                        // sinon on notifie le médiateur
                        //              getobservationMediateur().selection();
                                        // et on lui demande de synchroniser la selection avec les autres vues
                                //      getobservationMediateur().synchroniserSelection("liste");
                                }
                        }
                });
        }

        /**
         * Méthode héritée de l'interface VueListable
         * Sélectionne les observations  dans la liste suivant les identifiants donnés en paramètres
         */
        
        public String[] getIdSelectionnees() {
                
                Record[] selection = this.getSelectionModel().getSelections();
                int taille = selection.length;
                String id_selection[] = new String[taille];

                for (int i = 0; i < selection.length; i++) {

                        id_selection[i] = selection[i].getAsString("ordre_observation");
                }

                return id_selection;
        }
        
        /**
         * Méthode héritée de l'interface rafraichissable
         * @param nouvelleDonnees les nouvelles données
         * @param repandreRafraichissement le booleen de notification du rafraichissement
         */
        
        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRafraichissement) {

                // si on reçoit un store
                if (nouvelleDonnees instanceof Store) {
                
                        
                        // on affecte celui-ci comme gestionnaire de données
                        st = (Store) nouvelleDonnees;
                        st.load();
                        // et on reconfigure et rafraichit la vue
                        this.reconfigure(st, this.getColumnModel());
                        
                        demasquerChargement();
                        
                                                
                }

        }

        
        /**
         * Sélectionne des enregistrements donné 
         * @param sel un tableau d'enregistrement à selectionner
         */
        public void selectionnerEnregistrements(Record[] sel) {

                        getSelectionModel().clearSelections();
                        getSelectionModel().selectRecords(sel);
                
        }
        
        /**
         * Accesseur pour la toolbar de pagination
         * @return la toolbar de pagination
         */
        
        public BarrePaginationObservationVue getToolBarVue()
        {
                return bt ;
        }


        /**
         * Recherche l'élement actuellement affiché et affiche son message de chargement
         */
        public void masquerChargement()
        {
                        ExtElement masked = Ext.get(getId()) ;

                        // FIXME: parfois null sans raison !
                        if (masked!=null) {
                                masked.mask("Chargement") ;
                        }

        }
        
        /**
         * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
         */
        public void demasquerChargement()
        {
                        ExtElement masked = Ext.get(getId()) ;
                        
//                       FIXME: parfois null sans raison !
                        if (masked!=null) {
                                
                                if(masked.isMasked())
                                {
                                        masked.unmask() ;
                                }
                        }
        }
        



}