Subversion Repositories eFlore/Applications.del

Rev

Rev 391 | Rev 436 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
256 gduche 1 
package org.tela_botanica.del.client.composants.pagination;
120 gduche 2 
 
3 
import com.google.gwt.event.dom.client.ChangeEvent;
4 
import com.google.gwt.event.dom.client.ChangeHandler;
5 
import com.google.gwt.event.dom.client.ClickEvent;
6 
import com.google.gwt.event.dom.client.ClickHandler;
391 aurelien 7 
import com.google.gwt.event.dom.client.HasChangeHandlers;
8 
import com.google.gwt.event.dom.client.HasClickHandlers;
389 aurelien 9 
import com.google.gwt.user.client.Window;
391 aurelien 10 
import com.google.gwt.user.client.ui.HasText;
120 gduche 11 
import com.google.gwt.user.client.ui.HasWidgets;
391 aurelien 12 
import com.google.gwt.user.client.ui.IsWidget;
269 gduche 13 
/**
358 benjamin 14 
 * @author gregoire Pagination GENERIQUE qui permet d'afficher un nombre donné
15 
 *         d'éléments (pas) La méthode changerPage est abstraite et doit être
16 
 *         définie lors de l'instanciation de la classe pagination pour
17 
 *         permettre d'afficher la suite des éléments La méthode
18 
 *         actualiserPasCache est abstraite car le pas est différent en fonction
19 
 *         de la page où l'on se trouve
269 gduche 20 
 * */
120 gduche 21 
public abstract class PaginationPresenteur {
22 
 
391 aurelien 23 
	public interface Vue extends IsWidget {
24 
 
25 
		public HasWidgets getZoneLiens();
26 
		public int getNbWidgetsZoneLiens();
27 
		public HasClickHandlers getWidgetZoneLiensHasClickHandlers(int index);
28 
		public HasText getWidgetZoneLiensAsText(int index);
29 
		public void changerStyleBoutonZoneLiens(int index, String style);
30 
		public void ajouterBoutonZoneLiens(String label);
31 
		public HasClickHandlers getBoutonSuivant();
32 
		public HasClickHandlers getBoutonPrecedent();
33 
		public HasClickHandlers getBoutonPremierePage();
34 
		public HasClickHandlers getBoutonDernierePage();
412 aurelien 35 
		public void masquerBoutonPrecedent();
36 
		public void afficherBoutonPrecedent();
391 aurelien 37 
		public void masquerBoutonSuivant();
38 
		public void afficherBoutonSuivant();
412 aurelien 39 
		public boolean boutonPrecedentEstAffiche();
40 
		public boolean boutonSuivantEstAffiche();
391 aurelien 41 
		public HasChangeHandlers getSelecteurPas();
42 
		public int getPasSelectionne();
43 
		public void changerSelecteurPas(int index);
44 
	}
45 
	private Vue vue;
269 gduche 46 
	private int nbPage;
47 
	private int pageCourante = 1;
120 gduche 48 
	private int nbElementsTotal = 0;
263 gduche 49 
	private int pas = 10;
358 benjamin 50 
 
269 gduche 51 
	/**
52 
	 * Constructeur de l'application
358 benjamin 53 
	 *
54 
	 * @param nbElementsTotal
55 
	 *            : le nombre total des éléments à paginer
56 
	 * @param pas
57 
	 *            : le nombre d'éléments à afficher par page
269 gduche 58 
	 * */
391 aurelien 59 
	public PaginationPresenteur(PaginationPresenteur.Vue vue, int nbElementsTotal, int pas) {
269 gduche 60 
		this.nbElementsTotal = nbElementsTotal;
391 aurelien 61 
		this.vue = vue;
378 gduche 62 
		changerPas(this.pas);
120 gduche 63 
	}
358 benjamin 64 
 
65 
	/**
66 
	 * Methode go du modèle MVP
67 
	 *
68 
	 * @param container
69 
	 *            : la vue ou éxécuter l'affichage
70 
	 */
71 
	public void go(HasWidgets container) {
389 aurelien 72 
		gererEvenementsBoutonsStatiques();
358 benjamin 73 
		actualiserLiens();
391 aurelien 74 
		container.add(vue.asWidget());
358 benjamin 75 
	}
76 
 
269 gduche 77 
	/** Met à jour le nombre de page en fonction du pas */
391 aurelien 78 
	public void actualiserNbPage() {
269 gduche 79 
		Double nombrePages = Math.ceil((double) nbElementsTotal / (double) pas);
80 
		this.nbPage = nombrePages.intValue();
120 gduche 81 
	}
391 aurelien 82 
 
83 
	public void setNbPages(int nbPages) {
84 
		this.nbPage = nbPages;
85 
	}
86 
 
87 
	public int getNbPages() {
88 
		return nbPage;
89 
	}
412 aurelien 90 
 
91 
	public Vue getVue() {
92 
		return vue;
93 
	}
120 gduche 94 
 
358 benjamin 95 
	/**
96 
	 * Changer le pas de la pagination
97 
	 *
98 
	 * @param pas
99 
	 *            : le nombre d'éléments à afficher par page
100 
	 */
269 gduche 101 
	public void changerPas(int pas) {
390 aurelien 102 
		int ancienPas = this.pas;
391 aurelien 103 
		setPas(pas);
120 gduche 104 
		actualiserNbPage();
390 aurelien 105 
		gererDecalagePageCourante(ancienPas, pas);
391 aurelien 106 
		changerPage(pas * (pageCourante -1), pas * pageCourante);
389 aurelien 107 
		actualiserLiens();
391 aurelien 108 
		actualiserPasCache(pas);
109 
	}
110 
 
111 
	public void setPas(int pas) {
112 
		this.pas = pas;
358 benjamin 113 
		switch (pas) {
114 
		case 5:
391 aurelien 115 
			vue.changerSelecteurPas(0);
358 benjamin 116 
			break;
117 
		case 10:
391 aurelien 118 
			vue.changerSelecteurPas(1);
358 benjamin 119 
			break;
120 
		case 15:
391 aurelien 121 
			vue.changerSelecteurPas(2);
358 benjamin 122 
			break;
123 
		case 20:
391 aurelien 124 
			vue.changerSelecteurPas(3);
358 benjamin 125 
			break;
126 
		default:
127 
			break;
391 aurelien 128 
		}
120 gduche 129 
	}
390 aurelien 130 
 
131 
	private void gererDecalagePageCourante(int ancienPas, int nouveauPas) {
132 
		if(ancienPas != nouveauPas) {
133 
			double rapportPas = (double)ancienPas/(double)nouveauPas;
134 
			pageCourante = (int)(Math.ceil((double)pageCourante*(double)rapportPas));
135 
		}
136 
	}
358 benjamin 137 
 
138 
	/**
139 
	 * Actualiser les liens pour n'afficher 5 avant et 5 après
269 gduche 140 
	 * */
141 
	public void actualiserLiens() {
358 benjamin 142 
 
391 aurelien 143 
		HasWidgets zoneLiens = vue.getZoneLiens();
120 gduche 144 
		zoneLiens.clear();
358 benjamin 145 
 
269 gduche 146 
		int pageDebut = pagesAvant();
147 
		int pageFin = pagesApres();
358 benjamin 148 
 
269 gduche 149 
		for (int i = pageDebut; i < pageFin; i++) {
391 aurelien 150 
			vue.ajouterBoutonZoneLiens(i+"");
269 gduche 151 
		}
152 
		setBoutonActif();
389 aurelien 153 
		gererEvenementsBoutonsDynamiques();
269 gduche 154 
	}
358 benjamin 155 
 
269 gduche 156 
	private int pagesAvant() {
264 gduche 157 
		int pageDebut = pageCourante - 5;
263 gduche 158 
		if (pageDebut < 1) {
159 
			pageDebut = 1;
160 
		}
412 aurelien 161 
		if(pageCourante == 1) {
162 
			vue.masquerBoutonPrecedent();
163 
		} else {
164 
			vue.afficherBoutonPrecedent();
165 
		}
269 gduche 166 
		return pageDebut;
167 
	}
358 benjamin 168 
 
269 gduche 169 
	private int pagesApres() {
170 
		int pageFin = pageCourante + 5;
281 gduche 171 
		vue.afficherBoutonSuivant();
263 gduche 172 
		if (pageFin > nbPage) {
173 
			pageFin = nbPage;
412 aurelien 174 
		}
175 
		if(pageCourante == nbPage - 1) {
281 gduche 176 
			vue.masquerBoutonSuivant();
412 aurelien 177 
		} else {
178 
			vue.afficherBoutonSuivant();
263 gduche 179 
		}
412 aurelien 180 
 
269 gduche 181 
		return pageFin;
120 gduche 182 
	}
358 benjamin 183 
 
269 gduche 184 
	private void setBoutonActif() {
391 aurelien 185 
		int nbLiens = vue.getNbWidgetsZoneLiens();
358 benjamin 186 
		for (int i = 0; i < nbLiens; i++) {
391 aurelien 187 
			HasText boutonCourant = vue.getWidgetZoneLiensAsText(i);
269 gduche 188 
			if (boutonCourant.getText().equals(String.valueOf(pageCourante))) {
391 aurelien 189 
				vue.changerStyleBoutonZoneLiens(i,"actif");
269 gduche 190 
			} else {
391 aurelien 191 
				vue.changerStyleBoutonZoneLiens(i,"inactif");
120 gduche 192 
			}
193 
		}
269 gduche 194 
	}
120 gduche 195 
 
358 benjamin 196 
	/**
389 aurelien 197 
	 * Gérer les évènements sur les boutons statiques (précédent, suivant et selecteur pas)
269 gduche 198 
	 * */
389 aurelien 199 
	public void gererEvenementsBoutonsStatiques() {
391 aurelien 200 
		vue.getSelecteurPas().addChangeHandler(new ChangeHandler() {
120 gduche 201 
			@Override
202 
			public void onChange(ChangeEvent event) {
391 aurelien 203 
				changerPas(vue.getPasSelectionne());
378 gduche 204 
				synchroniser();
120 gduche 205 
			}
206 
		});
358 benjamin 207 
 
391 aurelien 208 
		vue.getBoutonPrecedent().addClickHandler(new ClickHandler() {
269 gduche 209 
			@Override
210 
			public void onClick(ClickEvent event) {
211 
				pagePrecedente();
212 
			}
213 
		});
120 gduche 214 
 
391 aurelien 215 
		vue.getBoutonSuivant().addClickHandler(new ClickHandler() {
269 gduche 216 
			@Override
217 
			public void onClick(ClickEvent event) {
218 
				pageSuivante();
219 
			}
220 
		});
391 aurelien 221 
 
222 
		vue.getBoutonPremierePage().addClickHandler(new ClickHandler() {
223 
			@Override
224 
			public void onClick(ClickEvent event) {
225 
				premierePage();
226 
			}
227 
		});
228 
 
229 
		vue.getBoutonDernierePage().addClickHandler(new ClickHandler() {
230 
			@Override
231 
			public void onClick(ClickEvent event) {
232 
				dernierePage();
233 
			}
234 
		});
389 aurelien 235 
	}
236 
 
237 
	/**
238 
	 * Gérer les évènements sur les boutons dynamiques (qui sont recréés à chaque fois)
239 
	 * */
240 
	public void gererEvenementsBoutonsDynamiques() {
391 aurelien 241 
		int nbLiens = vue.getNbWidgetsZoneLiens();
358 benjamin 242 
		for (int i = 0; i < nbLiens; i++) {
391 aurelien 243 
			HasClickHandlers boutonCourant = vue.getWidgetZoneLiensHasClickHandlers(i);
269 gduche 244 
			boutonCourant.addClickHandler(new ClickHandler() {
120 gduche 245 
				@Override
246 
				public void onClick(ClickEvent event) {
391 aurelien 247 
					HasText boutonCourant = (HasText)event.getSource();
269 gduche 248 
					pageCourante = Integer.parseInt(boutonCourant.getText());
382 aurelien 249 
					int debut = (Integer.parseInt(boutonCourant.getText()) - 1) * pas;
263 gduche 250 
					int fin = (debut + pas);
137 gduche 251 
					setBoutonActif();
120 gduche 252 
					changerPage(debut, fin);
269 gduche 253 
					actualiserLiens();
378 gduche 254 
					synchroniser();
120 gduche 255 
				}
256 
			});
257 
		}
258 
	}
391 aurelien 259 
 
260 
	public void premierePage() {
261 
		if (pageCourante > 1) {
262 
			pageCourante =  1;
263 
			int debut = (pageCourante -1) * pas;
264 
			int fin = debut + pas;
265 
			changerPage(debut, fin);
266 
			actualiserLiens();
267 
			synchroniser();
268 
		}
269 
	}
270 
 
271 
	public void dernierePage() {
272 
		if (pageCourante < nbPage - 1) {
273 
			pageCourante = nbPage - 1;
274 
			int debut = (pageCourante -1) * pas;
275 
			int fin = debut + pas;
276 
			changerPage(debut, fin);
277 
			actualiserLiens();
278 
			synchroniser();
279 
		}
280 
	}
120 gduche 281 
 
282 
	public void pageSuivante() {
264 gduche 283 
		if (pageCourante < nbPage - 1) {
284 
			pageCourante++;
382 aurelien 285 
			int debut = (pageCourante -1) * pas;
263 gduche 286 
			int fin = debut + pas;
120 gduche 287 
			changerPage(debut, fin);
269 gduche 288 
			actualiserLiens();
378 gduche 289 
			synchroniser();
120 gduche 290 
		}
291 
	}
358 benjamin 292 
 
120 gduche 293 
	public void pagePrecedente() {
269 gduche 294 
		if (pageCourante > 1) {
264 gduche 295 
			pageCourante--;
382 aurelien 296 
			int debut = (pageCourante -1) * pas;
263 gduche 297 
			int fin = debut + pas;
120 gduche 298 
			changerPage(debut, fin);
269 gduche 299 
			actualiserLiens();
378 gduche 300 
			synchroniser();
120 gduche 301 
		}
302 
	}
358 benjamin 303 
 
391 aurelien 304 
	public int getPageCourante() {
264 gduche 305 
		return this.pageCourante;
306 
	}
378 gduche 307 
 
391 aurelien 308 
	public int getPas() {
378 gduche 309 
		return this.pas;
310 
	}
311 
 
312 
	public void setPageCourante(int pageCourante) {
313 
		this.pageCourante = pageCourante;
314 
	}
120 gduche 315 
 
316 
	public abstract void changerPage(int debut, int fin);
358 benjamin 317 
 
263 gduche 318 
	public abstract void actualiserPasCache(int pas);
378 gduche 319 
 
320 
	public abstract void synchroniser();
120 gduche 321 
 
322 
}