Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;


import org.tela_botanica.client.i18n.Msg;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;

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 BarrePaginationVue extends Toolbar implements Rafraichissable {

        /**
         * Instance du médiateur à qui on notifie les évnènements
         */
        private ListePaginable listePaginable = 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(Msg.get("page")+" ");
        /**
         * Affichage de la page courante
         */
        private TextField champPage = new TextField("" + (pageCourante + 1));
        /**
         * Affichage de "sur pageTotale "
         */
        private ToolbarTextItem surTotalPage = new ToolbarTextItem(" "+Msg.get("sur")+" "
                        + pageTotale);
        /**
         * Texte statique de la toolbar 2
         */
        private ToolbarTextItem afficherNbElem = new ToolbarTextItem(Msg.get("afficher")+" ");
        /**
         * Combobox permettant de selectionner le nombre d'élements à afficher par
         * page et donc de changer la variable taillePage
         */
        private ComboBox selecteurTaillePage = new ComboBox();
        
        /**
         * Les différents intervalles de page possibles (intialisé par défaut)
         */
        String[] pages = { "200","100","50", "20", "10" };
        
        Store storeIntervalle = null ;
        
        

        /**
         * Label indiquant le type d'element affiché
         *  
         */     

        private String labelElement= Msg.get("elements");

        /**
         * taille de la page par defaut
         *  
         */     

        private int taillePageDefaut = 50;

        
        /**
         * Texte statique de la toolbar 3
         */
        private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
                        labelElement+" "+Msg.get("par-page")+" ");
        /**
         * Affiche l'intervalle des éléments contenus dans la page
         */
        private ToolbarTextItem intervalleElements = new ToolbarTextItem(labelElement + " "
                        + pageCourante * taillePage + " "+Msg.get("sur")+" " + nbElement);


        /**
         * retourne la liste associé à la barre
         */
        
        public ListePaginable getlistePaginable() {
                return listePaginable;
        }

        /***************************************************************************
         * constructeur sans argument (privé car ne doit pas être utilisé)
         */
        @SuppressWarnings("unused")
        private BarrePaginationVue() {
                super();
        }

        /**
         * constructeur avec paramètres
         * 
         * @param im
         *            le médiateur à associer à la barre
         */
        public BarrePaginationVue(ListePaginable lst) {
                super();

                listePaginable = lst;

                // on remplit l'espace pour que l'intervalle d'élement se place à droite
                // de la barre
                addItem(intervalleElements);
                addSpacer();
                // on remplit l'espace pour que l'intervalle d'élement se place à droite
                // de la barre
                addFill();
                
                // 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);

                prevPage.setIcon("page_prev.png");
                suivPage.setIcon("page_suiv.png");

                setIntervallesPages(pages) ;

                // 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(storeIntervalle);
                selecteurTaillePage.setEditable(false);
                addField(selecteurTaillePage);
                selecteurTaillePage.setValue(""+taillePageDefaut);
                selecteurTaillePage.setWidth(50);
                addItem(nbElemParPage);
                

                // on ajoute les différents listeners
                ajouterListeners();
        }

        
        /**
         *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
         *      @param label
         */
        
        public void setLabelElement(String label) {
                this.labelElement = label;
                nbElemParPage.setText(labelElement + " "+Msg.get("par-page")+" ");
                intervalleElements.setText(labelElement + " " + pageCourante * taillePage + " "+Msg.get("sur")+" " + nbElement);
        }

        public void setTaillePageParDefaut(int taille) {
                this.taillePageDefaut = taille;
                selecteurTaillePage.setValue(""+taillePageDefaut);
        }
        
        public void setIntervallesPages(String[] intervalle)
        {
                String[][] intervallesPages = new String[intervalle.length][1] ;
                
                for(int i = 0 ; i < intervalle.length ; i++)
                {
                        intervallesPages[i][0] = intervalle[i] ;
                }
                
                storeIntervalle = new SimpleStore(new String[] { "nb_page" },
                                intervallesPages );
                storeIntervalle.load();
                selecteurTaillePage.setStore(storeIntervalle);  
        }
        
        
        /**
         * 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() {

                        @Override
                        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
                                        listePaginable.changerNumeroPage(pageCourante);

                                }
                        }
                });

                suivPage.addListener(new ButtonListenerAdapter() {

                        @Override
                        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
                                        listePaginable.changerNumeroPage(pageCourante);

                                }
                        }
                });

                champPage.addListener(new TextFieldListenerAdapter() {

                        @Override
                        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);
                                                listePaginable.changerNumeroPage(pageCourante);

                                        } else {
                                                // sinon on reaffiche l'ancien numero de page sans rien
                                                // changer
                                                rafraichirNumeroPage();
                                                champPage.focus(true);
                                        }
                                }
                        }

                        @Override
                        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() {

                        @Override
                        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() {

                        @Override
                        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(" "+Msg.get("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(labelElement + " 0 - 0 "+Msg.get("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(labelElement + " " + pageCourante
                                                * taillePage + " - " + (pageCourante + 1) * taillePage
                                                + " "+Msg.get("sur")+" " + nbElement);
                        } else {
                                // on met simplement à jour l'intervalle qui contient toujours
                                // le même nombre d'éléments
                                intervalleElements.setText(labelElement + " " + pageCourante
                                                * taillePage + " - " + nbElement + " "+Msg.get("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
         */
        @Override
        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
                                listePaginable.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 string qui contient les différentes
         *         taille de pages
         */
        public String[] getNbPages() {

                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) {

                listePaginable.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);
        }

}