Subversion Repositories eFlore/Applications.coel

Rev

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

package org.tela_botanica.client.vues;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import org.tela_botanica.client.Mediateur;
import org.tela_botanica.client.i18n.Constantes;
import org.tela_botanica.client.i18n.ErrorMessages;
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.Debug;
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.store.StoreEvent;
import com.extjs.gxt.ui.client.store.StoreListener;
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.ComboBox.TriggerAction;
import com.extjs.gxt.ui.client.widget.form.SimpleComboBox;
import com.extjs.gxt.ui.client.widget.form.SimpleComboValue;
import com.extjs.gxt.ui.client.widget.form.NumberField;
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 Mediateur mediateur = null;
                private Constantes i18nC = null;
                private ErrorMessages i18nM = null;
                public int valeur = 0;
        
                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 NumberField champPage = new NumberField();
                private SimpleComboBox<Integer> selecteurTaillePage = new SimpleComboBox<Integer>();
        
                private LinkedList<Integer> intervallePages = new LinkedList<Integer>();
                private ListStore storeIntervalle = new ListStore() ;
                
                private String labelElement;
                private int taillePageDefaut = 50;
        
                public ListePaginable getlistePaginable() {
                                return listePaginable;
                }
        
                public void setlistePaginable(ListePaginable listePaginable) {
                                this.listePaginable = 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 listePaginableCourante, Mediateur mediateurCourant) {
                                super();
                
                                listePaginable = listePaginableCourante;                
                                mediateur = mediateurCourant;
                                i18nC = Mediateur.i18nC;
                                i18nM = Mediateur.i18nM;
                
                                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(i18nC.page());
                                page.setStyleAttribute("padding", "0 5px 0 5px");
                                add(page);
                
                                champPage.setValue(pageCourante+1);
                                champPage.setAllowDecimals(false);
                                champPage.setAllowNegative(false);
                                champPage.setStyleAttribute("text-align","right");
                                champPage.setWidth(30);
                                add(champPage);
                
                                surTotalPage = new Text(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(i18nC.afficher());
                                afficherNbElem.setStyleAttribute("padding", "0 5px 0 5px");
                                add(afficherNbElem);

                                // Attention l'appel à setTriggerAction avec ALL est indispensable
                                // pour éviter un bug lors de la selection de la taille de page par défaut
                                selecteurTaillePage.setTriggerAction(TriggerAction.ALL);
                                selecteurTaillePage.setLazyRender(false);
                                selecteurTaillePage.setWidth("40px");
                                setIntervallesPages();
                                add(selecteurTaillePage);
                
                                labelElement = i18nC.elements();
                
                                nbElemParPage = new Text(labelElement+" "+i18nC.parPage());
                                nbElemParPage.setStyleAttribute("padding-left", "5px");
                                add(nbElemParPage);
                
                                //Séparation
                                add(new SeparatorToolItem());
                                
                                intervalleElements = new Text(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(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())     {
                                                Integer intervalle = itIntervallePages.next();
                                                selecteurTaillePage.add(intervalle);
                                }

                                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);
                }
        
                /**
                 * 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);
                                                                }
                                                });

                                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 = champPage.getValue().intValue();

                                                                                                // 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();
                                                                                                }
                                                                                }
                                                                }
                                                });

                                // 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() {
                                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(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(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(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;
                }

                /**
                 * 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);
                }

                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();
                }
}