Subversion Repositories eFlore/Applications.del

Rev

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