Subversion Repositories eFlore/Applications.coel

package org.tela_botanica.client.vues;

import java.util.Iterator;

import java.util.LinkedList;

import org.tela_botanica.client.Mediateur;

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.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.widget.Text;

import com.extjs.gxt.ui.client.widget.button.Button;

import com.extjs.gxt.ui.client.widget.form.SimpleComboBox;

import com.extjs.gxt.ui.client.widget.form.TextField;

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 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 TextField<String> champPage = new TextField<String>();

	private SimpleComboBox selecteurTaillePage = new SimpleComboBox();

	private Text labelFiltre;

	private TextField<String> filtre;

	private Button annulerFiltre;

	private boolean filtreActive = false;

	private String termeRecherche = "";

	LinkedList<Integer> intervallePages = new LinkedList<Integer>();

	ListStore storeIntervalle = new ListStore() ;

	private String labelElement;

	private int taillePageDefaut = 50;

	public ListePaginable getlistePaginable() {

		return listePaginable;

	}

	public void setlistePaginable(ListePaginable listePaginable) {

		this.listePaginable = listePaginable;

	}

	private Mediateur mediateur;

	public int valeur = 0;

	/***************************************************************************

	 * 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 listePaginable, Mediateur mediateur) {

		super();

		this.listePaginable = listePaginable;

		this.mediateur = mediateur;

		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(mediateur.i18nC.page());

		page.setStyleAttribute("padding", "0 5px 0 5px");

		add(page);

		champPage.setValue(String.valueOf(pageCourante+1));

		champPage.setStyleAttribute("text-align","right");

		champPage.setWidth(30);

		add(champPage);

		surTotalPage = new Text(mediateur.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(mediateur.i18nC.afficher());

		afficherNbElem.setStyleAttribute("padding", "0 5px 0 5px");

		add(afficherNbElem);

		selecteurTaillePage.setWidth("40px");

		setIntervallesPages();

		add(selecteurTaillePage);

		labelElement = mediateur.i18nC.elements();

		nbElemParPage = new Text(labelElement + " " + mediateur.i18nC.parPage());

		nbElemParPage.setStyleAttribute("padding-left", "5px");

		add(nbElemParPage);

		//Séparation

		add(new SeparatorToolItem());

		labelFiltre = new Text("Recherche rapide : ");

		labelFiltre.setStyleAttribute("padding-right", "5px");

		add(labelFiltre);

		filtre = new TextField<String>();

		filtre.setWidth(150);

		this.add(filtre);

		annulerFiltre = new Button();

		annulerFiltre.setIcon(Images.ICONES.annuler());

		annulerFiltre.setVisible(false);

		add(annulerFiltre);

		add(new FillToolItem());

		intervalleElements = new Text(mediateur.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(mediateur.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())	{

			selecteurTaillePage.add(itIntervallePages.next());

		}

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

		annulerFiltre.setVisible(!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);

			}

		});

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

			public void componentSelected(ButtonEvent ce)	{

				filtre.setValue("");

				termeRecherche = "";

				filtreActive = false;

				listePaginable.changerNumeroPage(pageCourante);

				labelFiltre.setStyleAttribute("font-weight", "normal");

			}

		});

		filtre.addKeyListener(new KeyListener(){

			public void componentKeyUp(ComponentEvent ce) 	{

				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {

					termeRecherche = filtre.getValue();

					if (termeRecherche == null || termeRecherche.equals(""))	{

						filtreActive = false;

						labelFiltre.setStyleAttribute("font-weight", "normal");

						listePaginable.changerNumeroPage(pageCourante);

						changerEtatBarre(true);

					} else	{

						changerEtatBarre(false);

						listePaginable.filtrerParNom(termeRecherche);

						labelFiltre.setStyleAttribute("font-weight", "bold");

						filtreActive = true;

					}

				}

			}

		});

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

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

					}

				}

	}

		/*	public void onFocus(Field field) {

				champPage.focus();

			}*/

		});

		// pour éviter de se compliquer la vie, on filtre tous les charactères

		// non numériques

		champPage.addKeyListener(new KeyListener()	{

			public void componentKeyDown(ComponentEvent ce) 	{

				// si c'est un numerique

				/*

				FIXME

				if (Character.isDigit((char) e.getCharCode())) {

					// on laisse passer

					return;

				}*/

				// si c'est la touche entrée ou backspace (valider ou effacer)

				if (ce.getKeyCode() == KeyCodes.KEY_ENTER

						|| ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {

					// on laisse passer

					return;

				} else {

					// sinon on remet le numero de page correct et on annule

					// l'évenement

					rafraichirNumeroPage();

					ce.stopEvent();

				}

			}

		});

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

		if (filtreActive == true)	{

			intervalleElements.setText("<b><i>Recherche active : </i></b>" + termeRecherche);

		} else {

			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(mediateur.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(mediateur.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(mediateur.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;

	}

	/*

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

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

	}

	@Override

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

	}

}