Subversion Repositories eFlore/Applications.coel

Rev

Rev 1040 | Rev 1060 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.tela_botanica.client.vues;

import java.util.Iterator;
import java.util.LinkedList;

import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.images.Images;
import org.tela_botanica.client.interfaces.ListePaginable;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.util.UtilString;

import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.ComponentEvent;
import com.extjs.gxt.ui.client.event.KeyListener;
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.Text;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.SimpleComboBox;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.toolbar.FillToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.i18n.client.Dictionary;
import com.google.gwt.user.client.Window;

public class BarrePaginationVue extends ToolBar implements Rafraichissable {

        private ListePaginable listePaginable = null;
        
        private Button prevPage, suivPage, premierePage, dernierePage, rafraichir;
        
        private int pageCourante, nbElement = 0;
        private int taillePage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage"));
        private int pageTotale = 1;
        private Text page, surTotalPage, afficherNbElem, nbElemParPage, intervalleElements;
        
        private TextField<String> champPage = new TextField<String>();
        private SimpleComboBox selecteurTaillePage = new SimpleComboBox();
        private Text labelFiltre;
        private TextField<String> filtre;
        private Button annulerFiltre;
        private boolean filtreActive = false;
        private String termeRecherche = "";
        
        LinkedList<Integer> intervallePages = new LinkedList<Integer>();
        
        ListStore storeIntervalle = new ListStore() ;
                
        private String labelElement;
        private int taillePageDefaut = 50;
        
        public ListePaginable getlistePaginable() {
                return listePaginable;
        }
        
        public void setlistePaginable(ListePaginable listePaginable) {
                this.listePaginable = listePaginable;
        }
        
        private Mediateur mediateur;
        
        public int valeur = 0;
        /***************************************************************************
         * 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 listePaginable, Mediateur mediateur) {
                
                super();
                
                this.listePaginable = listePaginable;           
                this.mediateur = mediateur;
                
                intervallePages.add(10);
                intervallePages.add(20);
                intervallePages.add(50);
                intervallePages.add(100);
                intervallePages.add(200);
                
                premierePage = new Button();
                premierePage.setIcon(Images.ICONES.resultsetFirst());
                add(premierePage);
                
                prevPage = new Button();
                prevPage.setIcon(Images.ICONES.resultsetPrevious());
                add(prevPage);
                
                add(new SeparatorToolItem());           
                
                page = new Text(mediateur.i18nC.page());
                page.setStyleAttribute("padding", "0 5px 0 5px");
                add(page);
                
                champPage.setValue(String.valueOf(pageCourante+1));
                champPage.setStyleAttribute("text-align","right");
                champPage.setWidth(30);
                add(champPage);
                
                surTotalPage = new Text(mediateur.i18nC.sur() + " " + pageTotale);
                surTotalPage.setStyleAttribute("padding-left", "5px");
                add(surTotalPage);
                
                //Séparation
                add(new SeparatorToolItem());
                
                suivPage = new Button();
                suivPage.setIcon(Images.ICONES.resultsetNext());
                add(suivPage);
                
                dernierePage = new Button();
                dernierePage.setIcon(Images.ICONES.resultsetLast());
                add(dernierePage);

                //Séparation
                add(new SeparatorToolItem());
                
                rafraichir = new Button();
                rafraichir.setIcon(Images.ICONES.rafraichir());
                add(rafraichir);
                
                //Séparation
                add(new SeparatorToolItem());
                
                afficherNbElem = new Text(mediateur.i18nC.afficher());
                afficherNbElem.setStyleAttribute("padding", "0 5px 0 5px");
                add(afficherNbElem);

                
                selecteurTaillePage.setWidth("40px");
                setIntervallesPages();
                add(selecteurTaillePage);
                
                labelElement = mediateur.i18nC.elements();
                
                nbElemParPage = new Text(labelElement + " " + mediateur.i18nC.parPage());
                nbElemParPage.setStyleAttribute("padding-left", "5px");
                add(nbElemParPage);
                
                //Séparation
                add(new SeparatorToolItem());
                
                labelFiltre = new Text("Recherche rapide : ");
                labelFiltre.setStyleAttribute("padding-right", "5px");
                add(labelFiltre);
                
                filtre = new TextField<String>();
                filtre.setWidth(150);
                this.add(filtre);
                
                annulerFiltre = new Button();
                annulerFiltre.setIcon(Images.ICONES.annuler());
                annulerFiltre.setVisible(false);
                add(annulerFiltre);
                
                add(new FillToolItem());
                
                intervalleElements = new Text(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage, 
                                                                                                                                        (pageCourante + 1) * taillePage, nbElement));
                add(intervalleElements);
                
                // 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 + " par page ");
                intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage, 
                                (pageCourante + 1) * taillePage, nbElement));
                
        }

        public void setTaillePageParDefaut(int taille) {
                this.taillePageDefaut = taille;
                selecteurTaillePage.setRawValue(""+taillePageDefaut);
        }
        
        public void setIntervallesPages()
        {
                
                if (!intervallePages.contains(taillePage))      {
                        intervallePages.add(taillePage);
                }
                
                Iterator<Integer> itIntervallePages = intervallePages.iterator();
                while (itIntervallePages.hasNext())     {
                        selecteurTaillePage.add(itIntervallePages.next());
                }
                
                selecteurTaillePage.setSimpleValue(taillePage);
        }
        
        /**
         * Change l'état de la barre de pagination a actif ou inactif
         * @param etat actif ou inactif
         */
        private void changerEtatBarre(boolean etat)     {
                premierePage.setEnabled(etat);
                prevPage.setEnabled(etat);
                suivPage.setEnabled(etat);
                dernierePage.setEnabled(etat);
                champPage.setEnabled(etat);
                selecteurTaillePage.setEnabled(etat);
                page.setEnabled(etat);
                surTotalPage.setEnabled(etat);
                afficherNbElem.setEnabled(etat);
                nbElemParPage.setEnabled(etat);
                annulerFiltre.setVisible(!etat);
        }
        
        /**
         * ajoute les différents listeners nécessaires au bon fonctionnement des
         * éléments de la barre de pagination
         */
        @SuppressWarnings("unchecked")
        private void ajouterListeners() {
                
                premierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
                
                        public void componentSelected(ButtonEvent ce)   {
                                pageCourante = 0;
                                rafraichirNumeroPage();
                                listePaginable.changerNumeroPage(pageCourante);
                        }
                });
                
                // boutons suivants et précédents
                prevPage.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        
                        public void componentSelected(ButtonEvent ce) {
                                                        // 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.addSelectionListener(new SelectionListener<ButtonEvent>() {
                
                        public void componentSelected(ButtonEvent ce)   {
                                
                                // 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);
                                }
                        }
                });
                
                dernierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        
                        public void componentSelected(ButtonEvent ce)   {
                                pageCourante = pageTotale;
                                rafraichirNumeroPage();
                                listePaginable.changerNumeroPage(pageCourante);
                        }
                });
                
                rafraichir.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        
                        public void componentSelected(ButtonEvent ce)   {
                                listePaginable.changerNumeroPage(pageCourante);
                        }
                });
                
                annulerFiltre.addSelectionListener(new SelectionListener<ButtonEvent>() {
                        
                        public void componentSelected(ButtonEvent ce)   {
                                filtre.setValue("");
                                termeRecherche = "";
                                filtreActive = false;
                                listePaginable.changerNumeroPage(pageCourante);
                                labelFiltre.setStyleAttribute("font-weight", "normal");
                        }
                });
                
                filtre.addKeyListener(new KeyListener(){
                        public void componentKeyUp(ComponentEvent ce)   {
                                if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
                                        
                                        termeRecherche = filtre.getValue();
                                        if (termeRecherche == null || termeRecherche.equals(""))        {
                                                filtreActive = false;
                                                labelFiltre.setStyleAttribute("font-weight", "normal");
                                                listePaginable.changerNumeroPage(pageCourante);
                                                changerEtatBarre(true);
                                        } else  {
                                                changerEtatBarre(false);
                                                listePaginable.filtrerParNom(termeRecherche);
                                                labelFiltre.setStyleAttribute("font-weight", "bold");
                                                filtreActive = true;
                                        }
                                }
                        }
                });
                
                champPage.addKeyListener(new KeyListener() {

                        public void componentKeyUp(ComponentEvent ce)   {
                                
                                // on teste si la touche entrée a été pressée
                                if (ce.getKeyCode() == KeyCodes.KEY_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();
                                                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();
                                        }
                                }
        }

                
                /*      public void onFocus(Field field) {

                                champPage.focus();
                        }*/

                });

                // pour éviter de se compliquer la vie, on filtre tous les charactères
                // non numériques
                champPage.addKeyListener(new KeyListener()      {

                        public void componentKeyDown(ComponentEvent ce)         {

                                // si c'est un numerique
                                /*
                                FIXME
                                if (Character.isDigit((char) e.getCharCode())) {
                                
                                        // on laisse passer
                                        return;
                                }*/

                                // si c'est la touche entrée ou backspace (valider ou effacer)
                                if (ce.getKeyCode() == KeyCodes.KEY_ENTER
                                                || ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {
                                        // on laisse passer
                                        return;
                                } else {
                                        // sinon on remet le numero de page correct et on annule
                                        // l'évenement
                                        rafraichirNumeroPage();
                                        ce.stopEvent();
                                }
                        }

                });

                // listener pour la selection dans la combobox
                selecteurTaillePage.addSelectionChangedListener(
                                
                                new SelectionChangedListener() {
                                
                                        public void selectionChanged(SelectionChangedEvent e)   {
        
                                        SimpleComboBox comboBox = (SimpleComboBox) e.getSource();
                                        String nouvelleTaillePageString = comboBox.getRawValue();
                                        int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString);
                                                
                                        changerTaillePage(nouvelleTaillePage);
                                        
                                        rafraichirNumeroPage();                 
                        }

                });
        }
        
        /**
         * Met à jour les affichage sur les numéros de pages et d'intervalle
         * d'éléments à partir des variables de classes
         */
        public void rafraichirNumeroPage() {
                
                if (filtreActive == true)       {
                        intervalleElements.setText("<b><i>Recherche active : </i></b>" + termeRecherche);
                } else {
                
                        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(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), 0,0,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(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage, 
                                                        (pageCourante + 1) * taillePage, nbElement));
                                } else {
                                        
                                        // on met simplement à jour l'intervalle qui contient toujours
                                        // le même nombre d'éléments
                                        intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage, 
                                                        nbElement, nbElement));
                                }
                        }
                }
        }

        /**
         * Met à jour la page en cours
         * 
         * @param nouvellePageCourante
         *            la nouvelle page en cours
         */
        public void changerPageCourante(int nouvellePageCourante) {
                pageCourante = nouvellePageCourante;
        }

        /*
         * 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) {
                if (nouvelleTaillePage != taillePage)   {
                        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.setRawValue("" + nouvelleTaillePage);
        }

        @Override
        public void rafraichir(Object nouvelleDonnees) {
                // 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();
                
                layout();
        }

}