Subversion Repositories eFlore/Applications.del

package org.tela_botanica.del.client.composants.pagination;

import org.tela_botanica.del.client.navigation.evenement.BusEvenementiel;

import org.tela_botanica.del.client.navigation.evenement.pagination.EvenementChangementPage;

import org.tela_botanica.del.client.navigation.evenement.pagination.EvenementChangementPas;

import org.tela_botanica.del.client.navigation.evenement.pagination.GestionnaireEvenementChangementPage;

import org.tela_botanica.del.client.navigation.evenement.pagination.GestionnaireEvenementChangementPas;

import com.google.gwt.event.dom.client.ChangeEvent;

import com.google.gwt.event.dom.client.ChangeHandler;

import com.google.gwt.event.dom.client.ClickEvent;

import com.google.gwt.event.dom.client.ClickHandler;

import com.google.gwt.event.dom.client.HasChangeHandlers;

import com.google.gwt.event.dom.client.HasClickHandlers;

import com.google.gwt.user.client.ui.HasWidgets;

import com.google.gwt.user.client.ui.IsWidget;

/**

 * @author gregoire Pagination GENERIQUE qui permet d'afficher un nombre donné

 *         d'éléments (pas) La méthode changerPage est abstraite et doit être

 *         définie lors de l'instanciation de la classe pagination pour

 *         permettre d'afficher la suite des éléments La méthode

 *         actualiserPasCache est abstraite car le pas est différent en fonction

 *         de la page où l'on se trouve

 * */

public abstract class PaginationPresenteur {

	public interface Vue extends IsWidget {

		public HasClickHandlers getBoutonSuivant();

		public HasClickHandlers getBoutonPrecedent();

		public HasClickHandlers getBoutonPremierePage();

		public HasClickHandlers getBoutonDernierePage();

		public void masquerBoutonPrecedent();

		public void afficherBoutonPrecedent();

		public void masquerBoutonSuivant();

		public void afficherBoutonSuivant();

		public boolean boutonPrecedentEstAffiche();

		public boolean boutonSuivantEstAffiche();

		public HasChangeHandlers getSelecteurPas();

		public int getPasSelectionne();

		public void afficherPas(int pas);

		public void mettreNbTotalPages(int nbPages);

		public void mettreNbTotalResultats(int nbResultats);

		public HasChangeHandlers getSaisiePageCourante();

		public int getPageSaisie();

		public void setPageCourante(int pageCourante);

	}

	private Vue vue;

	private int nbPage = 1;

	//private int nbPage = 1;

	private int pageCourante = 1;

	private int nbElementsTotal = 0;

	private int pas = 10;

	private String groupePagination = null;

	/**

	 * Constructeur de l'application

	 *

	 * @param nbElementsTotal

	 *            : le nombre total des éléments à paginer

	 * @param pas

	 *            : le nombre d'éléments à afficher par page

	 * */

	public PaginationPresenteur(Vue vue, int nbElementsTotal, int pas, int pageCourante) {

		this.nbElementsTotal = nbElementsTotal;

		this.vue = vue;

		this.pas = pas;

		this.pageCourante = pageCourante;

		vue.setPageCourante(pageCourante);

		this.nbPage = calculerNbPage();

	}

	/**

	 * Methode go du modèle MVP

	 *

	 * @param container

	 *            : la vue ou éxécuter l'affichage

	 */

	public void go(HasWidgets container) {

		container.add(vue.asWidget());

		gererEvenements();

		actualiserPas();

		actualiserAffichageBoutons();

		vue.mettreNbTotalPages(nbPage);

		vue.mettreNbTotalResultats(nbElementsTotal);

	}

	/**

	 * Gérer les évènements sur les boutons statiques (précédent, suivant et

	 * selecteur pas)

	 * */

	protected void gererEvenements() {

		vue.getSaisiePageCourante().addChangeHandler(new ChangeHandler() {

			@Override

			public void onChange(ChangeEvent event) {

				int pageSaisie;

				try {

					pageSaisie = vue.getPageSaisie();

					if (pageSaisie < 0) {

						pageSaisie = 1;

					} else if (pageSaisie > nbPage){

						pageSaisie = nbPage;

					}

				} catch (NumberFormatException e) {

					pageSaisie = pageCourante;

				}

				pageCourante = pageSaisie;

				chargerElements(pas * (pageCourante - 1), pas * (pageCourante));

				vue.setPageCourante(pageCourante);

				actualiserAffichageBoutons();

			}

		});

		vue.getSelecteurPas().addChangeHandler(new ChangeHandler() {

			@Override

			public void onChange(ChangeEvent event) {

				int pasSelectionne;

				try {

					pasSelectionne = vue.getPasSelectionne();

					if (pasSelectionne < 0) {

						pasSelectionne = 1;

					} else if (pasSelectionne > 100){

						pasSelectionne = 100;

					}

				} catch (NumberFormatException e) {

					pasSelectionne = pas;

				}

				changerPas(pasSelectionne);

			}

		});

		vue.getBoutonPrecedent().addClickHandler(new ClickHandler() {

			@Override

			public void onClick(ClickEvent event) {

				allerALaPagePrecedente();

			}

		});

		vue.getBoutonSuivant().addClickHandler(new ClickHandler() {

			@Override

			public void onClick(ClickEvent event) {

				allerALapageSuivante();

			}

		});

		vue.getBoutonPremierePage().addClickHandler(new ClickHandler() {

			@Override

			public void onClick(ClickEvent event) {

				allerALaPremierePage();

			}

		});

		vue.getBoutonDernierePage().addClickHandler(new ClickHandler() {

			@Override

			public void onClick(ClickEvent event) {

				allerAlaDernierePage();

			}

		});

		BusEvenementiel.getInstance().addHandler(EvenementChangementPage.TYPE, new GestionnaireEvenementChangementPage() {

			@Override

			public void onChangementPage(EvenementChangementPage event) {

				if (event.getGroupePagination() == groupePagination) {

					pageCourante = event.getPageAAfficher();

					vue.setPageCourante(pageCourante);

					actualiserAffichageBoutons();

					vue.mettreNbTotalPages(nbPage);

					vue.mettreNbTotalResultats(nbElementsTotal);

				}

			}

		});

		BusEvenementiel.getInstance().addHandler(EvenementChangementPas.TYPE, new GestionnaireEvenementChangementPas() {

			@Override

			public void onChangementPas(EvenementChangementPas event) {

				if (event.getGroupePagination() == groupePagination) {

					// modifie le pas et les liens en fonction

					pas = event.getPas();

					actualiserPas();

				}

			}

		});

	}

	private void gererDecalagePageCourante(int ancienPas, int nouveauPas) {

		if (ancienPas != nouveauPas) {

			double rapportPas = (double) ancienPas / (double) nouveauPas;

			pageCourante = (int) (Math.ceil((double) pageCourante * (double) rapportPas));

		}

	}

	public void actualiserPas() {

		actualiserPasCache(pas);

		vue.afficherPas(pas);

	}

		public int getPageCourante() {

		return this.pageCourante;

	}

	public int getPas() {

		return this.pas;

	}

	public void setPageCourante(int pageCourante) {

		this.pageCourante = pageCourante;

	}

	public void changerPas(int nouveauPas) {

		// TODO corriger bug qui ne charge pas la bonne page ds certains cas

		// gererDecalagePageCourante(pas, nouveauPas);

		// pas = nouveauPas;

		// chargerElements((pageCourante - 1)*pas, pageCourante*pas);

		pas = nouveauPas;

		this.nbPage = calculerNbPage();

		chargerElements(0, pas);

		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPas(nouveauPas, groupePagination));

		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(1, groupePagination));

	}

	public void allerALaPagePrecedente() {

		if (pageCourante > 1) {

			int pageAAfficher = pageCourante - 1;

			pageCourante = pageAAfficher;

			chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));

			BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));

		}

	}

	public void allerALapageSuivante() {

		if (pageCourante < nbPage) {

			int pageAAfficher = pageCourante + 1;

			pageCourante = pageAAfficher;

			chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));

			BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));

		}

	}

	public void allerALaPremierePage() {

		int pageAAfficher = 1;

		pageCourante = pageAAfficher;

		chargerElements(0, pas);

		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));

	}

	public void allerAlaDernierePage() {

		int pageAAfficher = nbPage;

		pageCourante = pageAAfficher;

		chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));

		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));

	}

	/** calcule le nombre de page en fonction du pas */

	private int calculerNbPage() {

		Double nombrePages = Math.ceil((double) nbElementsTotal / (double) pas);

		return nombrePages.intValue();

	}

	public void setNbPages(int nbPages) {

		this.nbPage = nbPages;

	}

	public int getNbPages() {

		return nbPage;

	}

	public Vue getVue() {

		return vue;

	}

	public abstract void chargerElements(int debut, int fin);

	public abstract void actualiserPasCache(int pas);

	public void setPas(int pas) {

		this.pas = pas;

	}

	public void setGroupePagination(String groupePagination) {

		this.groupePagination = groupePagination;

	}

	public String getGroupePagination() {

		return groupePagination;

	}

	public void actualiserAffichageBoutons() {

		if (nbPage == 1) {

			vue.masquerBoutonPrecedent();

			vue.masquerBoutonSuivant();

		} else if (pageCourante == 1) {

			vue.masquerBoutonPrecedent();

			vue.afficherBoutonSuivant();

		} else {

			vue.afficherBoutonPrecedent();

			if (pageCourante == nbPage) {

				vue.masquerBoutonSuivant();

			}

		}

	}

}