Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;

import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;

import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Template;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;


/**
 * Barre de pagination asynchrone avec filtrage des touches et accès directs et séquentiels à une page
 * @author aurelien
 *
 */
public class BarrePaginationObservationVue extends Toolbar implements Rafraichissable {
        
        /**
         * Le médiateur associé à la vue
         */
        private ObservationMediateur    observationMediateur            = null;
        
        /**
         * Bouton précédent
         */
        private ToolbarButton prevPage = new ToolbarButton("<<") ;
        /**
         * Bouton suivant
         */
        private ToolbarButton suivPage = new ToolbarButton(">>") ;
        /**
         * Numéro de la page courante (attention, commence à zéro pour des raisons pratiques)
         */
        private int pageCourante = 0 ;
        /**
         * Nombre de page total
         */
        private int pageTotale = 1 ;
        /**
         * Nombre d'élements total
         */
        private int nbElement = 0 ;
        /**
         * Nombre d'élément par page
         */
        private int taillePage = 0 ;
        /**
         * Texte statique de la toolbar 1
         */
        private ToolbarTextItem page = new ToolbarTextItem("Page ") ;
        /**
         * Affichage de la page courante
         */
        private TextField champPage = new TextField(""+(pageCourante+1)) ;
        /**
         * Affichage de "sur pageTotale "
         */
        private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "+pageTotale) ;
        /**
         * Texte statique de la toolbar 2
         */
        private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ") ;
        /**
         * Combobox permettant de selectionner le nombre d'élements à afficher par page 
         * et donc de changer la variable taillePage 
         */
        private ComboBox selecteurTaillePage = new ComboBox() ;
        /**
         * Texte statique de la toolbar 3
         */
        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ;
        /**
         * Affiche l'intervalle des éléments contenus dans la page
         */
        private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ;

        /**
         * retourne le mediateur associe à la barre
         */
        public ObservationMediateur getImediateur()
        {
                return observationMediateur;
        }
                
        /***
         * constructeur sans argument (privé car ne doit pas être utilisé)
         */
        private  BarrePaginationObservationVue()
        {
                super() ;
        }
        
        /**
         * constructeur avec paramètres
         * @param im le médiateur à associer à la barre
         */
        public BarrePaginationObservationVue(ObservationMediateur im)
        {
                super() ;
                
                observationMediateur = im ;
                
                // on dispose un peu de texte et quelques espaces pour séparer les éléments
                addButton(prevPage) ;
                addSpacer() ;
                addItem(page) ;
                addField(champPage) ;
                addItem(surTotalPage) ;
                addSpacer() ;
                addButton(suivPage) ;
                
                champPage.setWidth(30) ;
                
                addSpacer() ;
                addItem(afficherNbElem) ;
                
                // le store contient les valeur possibles pour les tailles de page
                final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());  
                store.load();  
                
                // le template definit ce que l'on affiche pour chaque element du store dans la combobox
                final Template tp = new Template("<div class=\"x-combo-list-item\">" 
                                + "{nb_page}" 
                                + "<div class=\"x-clear\"></div></div>");
                tp.compile();
                
                selecteurTaillePage.setTpl(tp) ;
                selecteurTaillePage.setStore(store) ;
                selecteurTaillePage.setWidth(40) ;
                selecteurTaillePage.setEditable(false) ;
                addField(selecteurTaillePage) ;
                selecteurTaillePage.setValue("20") ;
                selecteurTaillePage.setWidth(50) ;
                addItem(nbElemParPage) ;
                
                // on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
                addFill() ;
                addItem(intervalleElements) ;
                addSpacer() ;
                
                // on ajoute les différents listeners
                ajouterListeners() ;
        }
        
        /**
         * ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination
         */
        private void ajouterListeners() 
        {
                // boutons suivants et précédents 
                prevPage.addListener(new ButtonListenerAdapter() {

                        
                        public void onClick(Button button, EventObject e) {
                                
                                // si la page courante n'est pas la première
                                if(pageCourante > 0)
                                {
                                        // on décrémente la page courante de 1
                                        pageCourante -- ;
                                        // on rafraichit l'affichage
                                        rafraichirNumeroPage() ;
                                        // et on notifie le médiateur de l'évenement
                                        observationMediateur.changerNumeroPage(pageCourante) ;
                                        
                                }
                        }
                }) ;
                
                suivPage.addListener(new ButtonListenerAdapter() {
                        
                        
                        public void onClick(Button button, EventObject e) {
                                
                                // si la page courante n'est pas la dernière
                                if(pageCourante  < pageTotale -1)
                                {
                                        // on incrémente la page courante de 1
                                        pageCourante ++ ;
                                        // on rafraichit l'affichage
                                        rafraichirNumeroPage() ;
                                        // et on notifie le médiateur de l'évenement
                                        observationMediateur.changerNumeroPage(pageCourante) ;
                                        
                                }       
                        }
                }) ;
                
                champPage.addListener(new TextFieldListenerAdapter() {

                        
                        public void onSpecialKey(Field field, EventObject e) {
                                
                                // on teste si la touche entrée a été pressée
                                if(e.getKey() == EventObject.ENTER)
                                {
                                        int nouvellePage = pageCourante ;
                                        // on teste avec parseInt si la valeur entrée est un entier
                                         try
                                         {
                                                nouvellePage = Integer.parseInt(champPage.getRawValue()) ;
                                         }
                                         // si ce n'est pas le cas alors on remet le numéro de page correct
                                         catch(NumberFormatException nfe)
                                         {
                                                 rafraichirNumeroPage() ;
                                                 champPage.focus(true) ;
                                                 return ;
                                         }
                                        
                                        // si la conversion reussit on verifie s'il est nécessaire de changer de page 
                                        // et si la nouvelle est comprise dans l'intervalle des pages existantes (0..pageTotale)
                                        if(nouvellePage != pageCourante + 1 && nouvellePage > 0 && nouvellePage <= pageTotale)
                                        {
                                                        // le cas échéant, on charge la nouvelle page et on notifie le médiateur
                                                        changerPageCourante(nouvellePage - 1) ;
                                                        observationMediateur.changerNumeroPage(pageCourante);

                                        }
                                        else
                                        {
                                                // sinon on reaffiche l'ancien numero de page sans rien changer
                                                rafraichirNumeroPage() ;
                                                champPage.focus(true) ;
                                        }
                                }
                        }
                        
                        
                        public void onFocus(Field field) {
                                
                                champPage.focus(true) ;
                        }
                        
                });
                
                // pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
                champPage.addKeyPressListener(new EventCallback() {

                        public void execute(EventObject e) {
                                
                                // si c'est un numerique
                                if(Character.isDigit((char)e.getCharCode()))
                                {
                                        // on laisse passer
                                        return ;
                                }
                                
                                // si c'est la touche entrée ou backspace (valider ou effacer)
                                if(e.getKey() == EventObject.ENTER || e.getKey() == EventObject.BACKSPACE)
                                {
                                        // on laisse passer
                                        return ;
                                }
                                else
                                {
                                        // sinon on remet le numero de page correct et on annule l'évenement
                                        rafraichirNumeroPage() ;
                                        e.stopEvent() ;
                                }                               
                        }
                        
                }) ;
                
                // listener pour la selection dans la combobox 
                selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
                        
                        
                        public void onSelect(ComboBox comboBox, Record record, int index) {
                                
                                String nouvelleTaillePageString = comboBox.getStore().getRecordAt(index).getAsString("nb_page") ;
                                int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString) ;
                                
                                // si la taille de page est différente de l'ancienne
                                if(nouvelleTaillePage != taillePage)
                                {
                                        // on la change
                                        changerTaillePage(nouvelleTaillePage) ;
                                }
                                // et on met la valeur à jour dans la combobox
                                comboBox.setValue(nouvelleTaillePageString) ;
                        }
                        
                }) ;
        }
        
        /**
         * Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments
         * à partir des variables de classes
         */
        public void rafraichirNumeroPage()
        {       
                surTotalPage.setText(" sur "+pageTotale) ;
                
                if(nbElement == 0)
                {
                        champPage.setValue(""+(0)) ;
                        // on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
                        intervalleElements.setText("Observations 0 - 0 sur 0") ;
                }
                else
                {
                        champPage.setValue(""+(pageCourante+1)) ;
                        
                        // si la page n'est pas la dernière 
                        if(pageCourante + 1 != pageTotale)
                        {
                                // sauf pour la dernière page qui contient souvent moins d'élements que le nombre d'élements par page
                                intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+(pageCourante+1)*taillePage+" sur "+nbElement) ;
                        }
                        else
                        {
                                // on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
                                intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+nbElement+" sur "+nbElement) ;
                        }
                }       
        }
        
        /**
         * Met à jour la page en cours 
         * @param nouvellePageCourante la nouvelle page en cours
         */
        public void changerPageCourante(int nouvellePageCourante)
        {
                pageCourante = nouvellePageCourante ;
        }
        
        /**
         * Methode héritée de l'interface rafraichissable
         */
        public void rafraichir(Object nouvelleDonnees,
                        boolean repandreRaffraichissement) {
                
                // si on reçoit un tableau de int
                if(nouvelleDonnees instanceof int[])
                {
                        int [] page = (int[])nouvelleDonnees ;
                        // le premier élement est le nombre de pages totales 
                        pageTotale = page[0] ;
                        // le second la page en cours
                        pageCourante = page[1] ;
                        // le troisième la taille de la page
                        taillePage = page[2] ;
                        // et le dernier le nombre total d'éléments
                        nbElement = page[3] ;
                        
                        // si la page courante dépasse la page totale (cas normalement improbable car géré en amont)
                        // on met le numéro de page à la page courante -1 (car la page courante est comptée à partir
                        // de zéro)
                        if(pageCourante >= pageTotale && pageCourante != 0)
                        {
                                pageCourante = pageTotale - 1 ;
                                // le cas échéant on en notifie le médiateur
                                observationMediateur.changerNumeroPage(pageCourante) ;
                        }
                }
                
                // enfin on rafraichit les informations affichées à partir des nouvelles variables de classes mises à jour
                rafraichirNumeroPage() ;
        }
        
        /**
         * Renvoie les différents intervalles de pages possibles
         * @return un tableau de tableau de string qui contient les différentes taille de pages 
         */
        public String[][] getNbPages()
        {
                String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ;
                
                return pages ;
        }

        /**
         * Envoie au médiateur une demande pour modifier la taille de la page
         * (qui va à son tour faire les modifications nécessaires)
         * @param nouvelleTaillePage la nouvelle taille de page (élement appartenant au tableau renvoyé par getNbPages())
         */
        public void changerTaillePage(int nouvelleTaillePage) {
                
                observationMediateur.changerTaillePage(nouvelleTaillePage) ;
                
        }
        
        
        
        /**
         * Selectionne la valeur correspond à celle passée en paramètre dans la combobox (si elle existe)
         * @param nouvelleTaillePage la nouvelle taille de page
         */
        public void selectionnerTaillePage(int nouvelleTaillePage) {
                
                selecteurTaillePage.setValue(""+nouvelleTaillePage) ;
        }
        
}