Subversion Repositories eFlore/Applications.del

Rev

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