Subversion Repositories eFlore/Applications.coel

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

		}

}