Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.observation.ObservationMediateur;

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 BarrePaginationObservationVue extends Toolbar implements Rafraichissable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ObservationMediateur	observationMediateur		= 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() ;

	/**

	 * Texte statique de la toolbar 3

	 */

	private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ;

	/**

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

	 */

	private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ;

	/**

	 * retourne le mediateur associe à la barre

	 */

	public ObservationMediateur getImediateur()

	{

		return observationMediateur;

	}

	/***

	 * constructeur sans argument (privé car ne doit pas être utilisé)

	 */

	private  BarrePaginationObservationVue()

	{

		super() ;

	}

	/**

	 * constructeur avec paramètres

	 * @param im le médiateur à associer à la barre

	 */

	public BarrePaginationObservationVue(ObservationMediateur im)

	{

		super() ;

		observationMediateur = im ;

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

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

		final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());

		store.load();

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

		selecteurTaillePage.setWidth(40) ;

		selecteurTaillePage.setEditable(false) ;

		addField(selecteurTaillePage) ;

		selecteurTaillePage.setValue("20") ;

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

	}

	/**

	 * 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

					observationMediateur.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

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

							observationMediateur.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("Observations 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("Observations "+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("Observations "+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

				observationMediateur.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 tableau de string qui contient les différentes taille de pages

	 */

	public String[][] getNbPages()

	{

		String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ;

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

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

	}

}