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 org.tela_botanica.client.composants.ChampFiltreRecherche;

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;

	private ChampFiltreRecherche champFiltreRecherche = null;

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

	}

	public BarrePaginationVue(ListePaginable listePaginableCourante, Mediateur mediateurCourant, ChampFiltreRecherche champFiltreRechercheCourant) {

		this(listePaginableCourante, mediateurCourant);

		champFiltreRecherche = champFiltreRechercheCourant;

	}

	/**

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

					changePage();

				}

			});

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

						changePage();

					}

				}

			});

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

						changePage();

					}

				}

			});

		dernierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {

				public void componentSelected(ButtonEvent ce)	{

					pageCourante = pageTotale;

					rafraichirNumeroPage();

					changePage();

				}

			});

		rafraichir.addSelectionListener(new SelectionListener<ButtonEvent>() {

				public void componentSelected(ButtonEvent ce)	{

					changePage();

				}

			});

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

							changePage();

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

				}

			});

	}

	public void changePage() {

		// si notre barre de pagination n'a pas été initialisée

		// avec un filtre de recherche, contentons-nous de changer de page

		// Attention, car tous les webservice ne supporte pas un segment d'URI "null" (500)

		if(champFiltreRecherche == null || champFiltreRecherche.getFiltreValue() == null) {

			// et on notifie le médiateur de l'évenement

			listePaginable.changerNumeroPage(pageCourante);

		} else {

			// autrement nous pouvons changer de page *tout en conservant* le filtre de recherche,

			// charge au modèle de cette liste d'avoir implémenté correctement filtrerParNomEtPage()

			listePaginable.filtrerParNomEtPage(champFiltreRecherche.getFiltreValue(), pageCourante);

		}

	}

	/**

	 * 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 allerALaDernierePage() {

		changerPageCourante(pageTotale);

		changePage();

	}

	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

				changePage();

			}

		}

		// enfin on rafraichit les informations affichées à partir des nouvelles

		// variables de classes mises à jour

		rafraichirNumeroPage();

		layout();

	}

}