Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;

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

	/**

	 * Affichage de la page courante

	 */

	private TextField champPage = new TextField("" + (pageCourante + 1));

	/**

	 * Affichage de "sur pageTotale "

	 */

	private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "

			+ pageTotale);

	/**

	 * Texte statique de la toolbar 2

	 */

	private ToolbarTextItem afficherNbElem = new ToolbarTextItem("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="Elements";

	/**

	 * taille de la page par defaut

	 *

	 */

	private int taillePageDefaut = 50;

	/**

	 * Texte statique de la toolbar 3

	 */

	private ToolbarTextItem nbElemParPage = new ToolbarTextItem(

			labelElement + " par page ");

	/**

	 * Affiche l'intervalle des éléments contenus dans la page

	 */

	private ToolbarTextItem intervalleElements = new ToolbarTextItem(labelElement + " "

			+ pageCourante * taillePage + " 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 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");

		// le store contient les valeur possibles pour les tailles de page

		/*final Store store = new SimpleStore(new String[] { "nb_page" },

				new String[][] {getNbPages()} );

		store.load();*/

		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.setWidth(40);

		selecteurTaillePage.setEditable(false);

		addField(selecteurTaillePage);

		selecteurTaillePage.setValue(""+taillePageDefaut);

		selecteurTaillePage.setWidth(50);

		addItem(nbElemParPage);

		// on remplit l'espace pour que l'intervalle d'élement se place à droite

		// de la barre

		addFill();

		addItem(intervalleElements);

		addSpacer();

		// 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(labelElement + " " + pageCourante * taillePage + " 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() {

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

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

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

					}

				}

			}

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

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

			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(" 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 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

						+ " 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 + " 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

	 */

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

	}

}