Subversion Repositories eFlore/Applications.cel

Rev

Rev 235 | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.tela_botanica.client.vues.image;

import java.util.Iterator;

import org.tela_botanica.client.image.ImageMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.ListeObservation;
import org.tela_botanica.client.modeles.Observation;

import com.google.gwt.user.client.Window;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.dd.DragSource;
import com.gwtext.client.dd.DropTarget;
import com.gwtext.client.dd.DropTargetConfig;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.Container;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridDragData;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.event.GridListenerAdapter;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.dd.DragData;

/**
 * liste d'observation pour l'association d'images aux observations
 * @author aurelien
 *
 */
public class MiniListeObservationVue extends GridPanel implements Rafraichissable {

        /**
         * Le médiateur associé à la vue
         */
        private ImageMediateur iMediateur = null ;
        
        /**
         * Booléen d'instanciation
         */
        private boolean estInstancie = false ;
        
        /**
         * Le modèle de colonnes
         */
        private ColumnModel colModel = null ;
        
        private SimpleStore store = null ;
        
        //private BarrePaginationVue pgBar = new BarrePaginationVue(iMediateur) ;
        
        private Toolbar bt = new Toolbar() ;
        
        /**
         * Combobox permettant de selectionner le mode
         * modification ou bien création
         */
        private ComboBox selecteurMode = new ComboBox();
        
        Store storeMode = null ;

        private boolean liaison;
        
        /**
         * Constructeur avec arguments
         * @param im le médiateur à associer à la vue
         */
        public MiniListeObservationVue(ImageMediateur im)
        {
                iMediateur = im ;
                
                this.setId("x-view-mini-obs") ;
                
                // on crée un store simple contenant un petit set de données et deux colonnes
                store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, getObs());  
                ColumnConfig[] columns = {  
                new ColumnConfig("Numero", "id_obs", 50, true),   
                new ColumnConfig("Taxon", "plante", 145, true), 
                new ColumnConfig("Date", "date", 68, true),
                new ColumnConfig("Lieu", "lieu", 145, true) } ;
                   
        ColumnModel columnModel = new ColumnModel(columns);
         
        colModel = columnModel ;

         
        setTitle("Observations");  
        // on associe le modèle de colonnes
        setColumnModel(columnModel);  
        setAutoScroll(true) ;
        setHeight("100%") ;
                setAutoWidth(true) ; 
        // on autorise le drag 'n drop pour un certain groupe
                this.setEnableDragDrop(true);
                this.setDdGroup("DragGroupName");
        store.load();       
                setStore(store) ;
                
                //setBottomToolbar(pgBar) ;
                
                Object[][] mode = {{"toutes les observations",false} , {"observations liées", true} };
                storeMode = new SimpleStore(new String[] { "nom_mode", "mode" },
                                mode);
                storeMode.load();
                selecteurMode.setStore(storeMode);
                selecteurMode.setDisplayField("nom_mode") ;
                selecteurMode.setLabel("mode ") ;
                selecteurMode.setForceSelection(true) ;
                selecteurMode.setValue("toutes les observations") ;
                selecteurMode.setEditable(false) ;
                selecteurMode.setCls("x-selec-consult") ;
                
                bt = new Toolbar() ;
                bt.addField(selecteurMode) ;
                
                //this.setAutoExpandColumn("plante");
                
                setTopToolbar(bt) ;
                
                selecteurMode.addListener(new ComboBoxListenerAdapter() {

                        public void onSelect(ComboBox comboBox, Record record, int index) {
                                
                                // et on met la valeur à jour dans la combobox
                                comboBox.setValue(record.getAsString("nom_mode"));
                                setModification(record.getAsString("mode")) ;
                        }

                });
                
                setAutoScroll(true) ;
                // on configure le drag 'n drop
                configDragAndDrop() ;
                
                this.addListener(new ContainerListenerAdapter() {
                        
                        public void onRender(Component c) {
                                
                                obtenirMiniListeObservations() ;
                                
                        }
                        
                        public void onAfterLayout(Container c)
                        {
                                obtenirMiniListeObservations() ;
                        }
                        
                }) ;
                
                this.addGridListener(new GridListenerAdapter() {

                        public void onContextMenu(EventObject e) {
                                
                                e.stopEvent() ;
                                MenuLiaisonVue mlv = new MenuLiaisonVue(iMediateur,liaison) ;
                                mlv.showAt(e.getXY()) ;
                                
                        }
                        
                }) ;               
        }
        
        /**
         * Configure le drag 'n drop pour la liste
         */
        private void configDragAndDrop()
        {
                // on choisit le texte qui sera affiché lors d'un drag 'n drop
                setDragDropText("Faites glisser la selection d'observations sur une image pour les lier") ;
                
                //On active le drag 'n drop
                this.setEnableDragDrop(true);

                // on fabrique la nouvelle configuration
                // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup
                this.setDdGroup("DragGroupName");
                DropTargetConfig dtc = new DropTargetConfig();
                dtc.setdDdGroup("DragGroupName");

                //La drop target permet de gérer l'évenement onDrop sur l'élement courant
                @SuppressWarnings("unused")
                DropTarget tg = new DropTarget(this, dtc)
                {
                        public boolean notifyDrop(DragSource source, EventObject e, DragData data){     
                                
                                // si on reçoit des données provenant d'une grille
                                if(data instanceof GridDragData)
                          {
                                        // on la convertit 
                                        GridDragData gdd = (GridDragData)data ;
                                        // et on vérifie que les données ne viennent pas de l'élément courant
                                        if(gdd.getGrid().getId().equals("x-view-mini-obs"))
                                        {
                                                return false ;
                                        }
                                        else
                                        {
                                                // on appelle le médiateur
                                                return iMediateur.lierImagesDD(source, e, data) ;   
                                        }
                          }
                                return false ;
                        }
                        
                        public String notifyOver(DragSource source, EventObject e, DragData data){
                            return "x-dd-drop-ok";
                        }
                };
        
        }
        
        /**
         * Méthode héritée de l'interface rafraichissable
         */
        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRaffraichissement) {
                
                if(nouvelleDonnees instanceof ListeObservation)
                {
                        if(this.getView() != null)
                        {
                                ListeObservation data = (ListeObservation)nouvelleDonnees ;
                                String[][] listeObs = new String[data.size()][4] ;
                                int i = 0 ;
                                
                                for (Iterator it = data.keySet().iterator(); it.hasNext();) 
                                {
                                        
                                        Observation obs=(Observation) data.get(it.next());
                                        
                                        listeObs[i][0] = obs.getNumeroOrdre();
                                        listeObs[i][1] = obs.getNomSaisi();
                                        listeObs[i][2] = obs.getDate() ;
                                        listeObs[i][3] = obs.getLocalite();
                                
                                        i++ ;
                                }
        
                                store = new SimpleStore(new String[]{"id_obs","plante","date","lieu"}, listeObs);       
                                store.load();       
                                this.reconfigure(store, colModel) ;
                        }
                        else
                        {
                                addListener(new ContainerListenerAdapter() {
                                        
                                        public void onShow(Component c)
                                        {
                                                obtenirMiniListeObservations() ;
                                        }
                                        
                                        public void onAfterLayout(Container c)
                                        {
                                                obtenirMiniListeObservations() ;
                                        }
                                        
                                }) ;
                        }
        
                }
                
                deMasquerChargement() ;
                
        }
        
        private void obtenirMiniListeObservations()
        {
                iMediateur.obtenirMiniListeObservations(this) ;
        }
        
        /**
         * Renvoie le faux set de données pour le store
         * @return un tableau à deux colonnes int - String
         */
        private Object[][] getObs() {  
                 return new Object[][]{  
                              
                 } ;
         }
        
        public Store getStore()
        {
                return store ;
        }
        
        /*public BarrePaginationVue getBarrePagination()
        {
                return pgBar ;
        }*/
        
        private void setModification(String mode)
        {
                if(mode.equals("true")) {

                        liaison = true ;
                        selecteurMode.removeClass("x-selec-consult") ;
                        selecteurMode.setCls("x-selec-liaison") ;
                }
                else
                {
                        liaison = false ;
                        selecteurMode.removeClass("x-selec-liaison") ;
                        selecteurMode.setCls("x-selec-consult") ;
                        
                }
                
                masquerChargement() ;
                store.removeAll() ;
                iMediateur.changerModeLiaison(liaison) ;
                
        }
        
        public boolean getMode() {
                return liaison ;
        }
        
        /**
         * Recherche l'élement actuellement affiché et affiche son message de chargement
         */
        public void masquerChargement()
        {
                        ExtElement masked = Ext.get(getId()) ;

                        if (masked!=null) {
                                masked.mask("Chargement") ;
                        }
        }
        
        /**
         * Recherche l'élement actuellement affiché et affiche son message de chargement
         */
        public void deMasquerChargement()
        {
                        ExtElement masked = Ext.get(getId()) ;

                        if (masked!=null) {
                                masked.unmask() ;
                        }
        }
        
        public String getIdSelectionnees() {
                
                Record[] sels = getSelectionModel().getSelections() ;
                String id = sels[0].getAsString("id_obs") ;
                
                return id ;
                
        }
        
        public void supprimerLiaison() {
                
                
                Record[] rdObs = getSelectionModel().getSelections() ;
                
                for(int i = 0 ; i < rdObs.length ; i++) {
                        
                        getStore().remove(rdObs[i]) ;
                        this.getView().refresh() ;
                
                }
                
        }
        
        public void redimensionner() {
                if(getView() != null) {
                                
                                this.setWidth("100%");
                                getView().setForceFit(true);
                                doLayout();
                }
                else {
                        Window.alert("null");                   
                }
        }
}