Subversion Repositories eFlore/Applications.del

Rev

Go to most recent revision | Details | 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
 
445 benjamin 3
import org.tela_botanica.del.client.navigation.evenement.BusEvenementiel;
4
import org.tela_botanica.del.client.navigation.evenement.pagination.EvenementChangementPage;
5
import org.tela_botanica.del.client.navigation.evenement.pagination.EvenementChangementPas;
6
import org.tela_botanica.del.client.navigation.evenement.pagination.GestionnaireEvenementChangementPage;
7
import org.tela_botanica.del.client.navigation.evenement.pagination.GestionnaireEvenementChangementPas;
120 gduche 8
import com.google.gwt.event.dom.client.ChangeEvent;
9
import com.google.gwt.event.dom.client.ChangeHandler;
10
import com.google.gwt.event.dom.client.ClickEvent;
11
import com.google.gwt.event.dom.client.ClickHandler;
391 aurelien 12
import com.google.gwt.event.dom.client.HasChangeHandlers;
13
import com.google.gwt.event.dom.client.HasClickHandlers;
120 gduche 14
import com.google.gwt.user.client.ui.HasWidgets;
391 aurelien 15
import com.google.gwt.user.client.ui.IsWidget;
436 benjamin 16
 
269 gduche 17
/**
358 benjamin 18
 * @author gregoire Pagination GENERIQUE qui permet d'afficher un nombre donné
19
 *         d'éléments (pas) La méthode changerPage est abstraite et doit être
20
 *         définie lors de l'instanciation de la classe pagination pour
21
 *         permettre d'afficher la suite des éléments La méthode
22
 *         actualiserPasCache est abstraite car le pas est différent en fonction
23
 *         de la page où l'on se trouve
269 gduche 24
 * */
120 gduche 25
public abstract class PaginationPresenteur {
26
 
391 aurelien 27
	public interface Vue extends IsWidget {
28
		public HasClickHandlers getBoutonSuivant();
29
		public HasClickHandlers getBoutonPrecedent();
30
		public HasClickHandlers getBoutonPremierePage();
31
		public HasClickHandlers getBoutonDernierePage();
412 aurelien 32
		public void masquerBoutonPrecedent();
33
		public void afficherBoutonPrecedent();
391 aurelien 34
		public void masquerBoutonSuivant();
35
		public void afficherBoutonSuivant();
412 aurelien 36
		public boolean boutonPrecedentEstAffiche();
37
		public boolean boutonSuivantEstAffiche();
391 aurelien 38
		public HasChangeHandlers getSelecteurPas();
39
		public int getPasSelectionne();
445 benjamin 40
		public void afficherPas(int pas);
488 benjamin 41
		public void mettreNbTotalPages(int nbPages);
568 gduche 42
		public HasChangeHandlers getSaisiePageCourante();
43
		public int getPageSaisie();
44
		public void setPageCourante(int pageCourante);
391 aurelien 45
	}
436 benjamin 46
 
391 aurelien 47
	private Vue vue;
445 benjamin 48
	private int nbPage = 1;
269 gduche 49
	private int pageCourante = 1;
120 gduche 50
	private int nbElementsTotal = 0;
263 gduche 51
	private int pas = 10;
564 benjamin 52
 
446 aurelien 53
	private String groupePagination = null;
358 benjamin 54
 
269 gduche 55
	/**
56
	 * Constructeur de l'application
358 benjamin 57
	 *
58
	 * @param nbElementsTotal
59
	 *            : le nombre total des éléments à paginer
60
	 * @param pas
61
	 *            : le nombre d'éléments à afficher par page
269 gduche 62
	 * */
445 benjamin 63
	public PaginationPresenteur(Vue vue, int nbElementsTotal, int pas, int pageCourante) {
269 gduche 64
		this.nbElementsTotal = nbElementsTotal;
391 aurelien 65
		this.vue = vue;
445 benjamin 66
		this.pas = pas;
67
		this.pageCourante = pageCourante;
568 gduche 68
		vue.setPageCourante(pageCourante);
446 aurelien 69
		this.nbPage = calculerNbPage();
120 gduche 70
	}
358 benjamin 71
 
72
	/**
73
	 * Methode go du modèle MVP
74
	 *
75
	 * @param container
76
	 *            : la vue ou éxécuter l'affichage
77
	 */
78
	public void go(HasWidgets container) {
391 aurelien 79
		container.add(vue.asWidget());
445 benjamin 80
		gererEvenements();
81
		actualiserPas();
566 gduche 82
		actualiserAffichageBoutons();
679 gduche 83
		vue.mettreNbTotalPages(nbPage);
358 benjamin 84
	}
85
 
86
	/**
436 benjamin 87
	 * Gérer les évènements sur les boutons statiques (précédent, suivant et
88
	 * selecteur pas)
269 gduche 89
	 * */
445 benjamin 90
	protected void gererEvenements() {
568 gduche 91
 
92
		vue.getSaisiePageCourante().addChangeHandler(new ChangeHandler() {
93
			@Override
94
			public void onChange(ChangeEvent event) {
95
				int pageSaisie;
96
				try {
97
					pageSaisie = vue.getPageSaisie();
98
					if (pageSaisie < 0) {
99
						pageSaisie = 1;
100
					} else if (pageSaisie > nbPage){
101
						pageSaisie = nbPage;
102
					}
103
				} catch (NumberFormatException e) {
104
					pageSaisie = pageCourante;
105
				}
106
				pageCourante = pageSaisie;
107
				chargerElements(pas * (pageCourante - 1), pas * (pageCourante));
108
				vue.setPageCourante(pageCourante);
109
				actualiserAffichageBoutons();
110
			}
111
		});
112
 
391 aurelien 113
		vue.getSelecteurPas().addChangeHandler(new ChangeHandler() {
120 gduche 114
			@Override
115
			public void onChange(ChangeEvent event) {
567 gduche 116
				int pasSelectionne;
117
				try {
118
					pasSelectionne = vue.getPasSelectionne();
119
					if (pasSelectionne < 0) {
120
						pasSelectionne = 1;
1245 gduche 121
					} else if (pasSelectionne > 100){
122
						pasSelectionne = 100;
567 gduche 123
					}
124
				} catch (NumberFormatException e) {
125
					pasSelectionne = pas;
126
				}
127
 
128
				changerPas(pasSelectionne);
120 gduche 129
			}
130
		});
358 benjamin 131
 
391 aurelien 132
		vue.getBoutonPrecedent().addClickHandler(new ClickHandler() {
269 gduche 133
			@Override
134
			public void onClick(ClickEvent event) {
445 benjamin 135
				allerALaPagePrecedente();
269 gduche 136
			}
137
		});
120 gduche 138
 
391 aurelien 139
		vue.getBoutonSuivant().addClickHandler(new ClickHandler() {
269 gduche 140
			@Override
141
			public void onClick(ClickEvent event) {
445 benjamin 142
				allerALapageSuivante();
269 gduche 143
			}
144
		});
436 benjamin 145
 
391 aurelien 146
		vue.getBoutonPremierePage().addClickHandler(new ClickHandler() {
147
			@Override
148
			public void onClick(ClickEvent event) {
446 aurelien 149
				allerALaPremierePage();
391 aurelien 150
			}
151
		});
152
 
153
		vue.getBoutonDernierePage().addClickHandler(new ClickHandler() {
154
			@Override
155
			public void onClick(ClickEvent event) {
446 aurelien 156
				allerAlaDernierePage();
391 aurelien 157
			}
158
		});
445 benjamin 159
 
160
		BusEvenementiel.getInstance().addHandler(EvenementChangementPage.TYPE, new GestionnaireEvenementChangementPage() {
161
 
162
			@Override
163
			public void onChangementPage(EvenementChangementPage event) {
564 benjamin 164
				if (event.getGroupePagination() == groupePagination) {
446 aurelien 165
					pageCourante = event.getPageAAfficher();
568 gduche 166
					vue.setPageCourante(pageCourante);
566 gduche 167
					actualiserAffichageBoutons();
679 gduche 168
					vue.mettreNbTotalPages(nbPage);
446 aurelien 169
				}
445 benjamin 170
			}
171
		});
172
 
173
		BusEvenementiel.getInstance().addHandler(EvenementChangementPas.TYPE, new GestionnaireEvenementChangementPas() {
174
 
175
			@Override
176
			public void onChangementPas(EvenementChangementPas event) {
564 benjamin 177
				if (event.getGroupePagination() == groupePagination) {
446 aurelien 178
					// modifie le pas et les liens en fonction
179
					pas = event.getPas();
180
					actualiserPas();
181
				}
445 benjamin 182
			}
183
		});
389 aurelien 184
	}
564 benjamin 185
 
186
	private void gererDecalagePageCourante(int ancienPas, int nouveauPas) {
187
		if (ancienPas != nouveauPas) {
188
			double rapportPas = (double) ancienPas / (double) nouveauPas;
189
			pageCourante = (int) (Math.ceil((double) pageCourante * (double) rapportPas));
446 aurelien 190
		}
191
	}
564 benjamin 192
 
445 benjamin 193
	public void actualiserPas() {
194
		actualiserPasCache(pas);
195
		vue.afficherPas(pas);
391 aurelien 196
	}
436 benjamin 197
 
568 gduche 198
		public int getPageCourante() {
264 gduche 199
		return this.pageCourante;
200
	}
436 benjamin 201
 
391 aurelien 202
	public int getPas() {
378 gduche 203
		return this.pas;
204
	}
436 benjamin 205
 
378 gduche 206
	public void setPageCourante(int pageCourante) {
207
		this.pageCourante = pageCourante;
208
	}
564 benjamin 209
 
446 aurelien 210
	public void changerPas(int nouveauPas) {
564 benjamin 211
 
212
		// TODO corriger bug qui ne charge pas la bonne page ds certains cas
213
		// gererDecalagePageCourante(pas, nouveauPas);
214
		// pas = nouveauPas;
215
		// chargerElements((pageCourante - 1)*pas, pageCourante*pas);
446 aurelien 216
		pas = nouveauPas;
679 gduche 217
		this.nbPage = calculerNbPage();
564 benjamin 218
		chargerElements(0, pas);
446 aurelien 219
		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPas(nouveauPas, groupePagination));
491 benjamin 220
		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(1, groupePagination));
446 aurelien 221
	}
120 gduche 222
 
445 benjamin 223
	public void allerALaPagePrecedente() {
224
		if (pageCourante > 1) {
225
			int pageAAfficher = pageCourante - 1;
446 aurelien 226
			pageCourante = pageAAfficher;
445 benjamin 227
			chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
446 aurelien 228
			BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
445 benjamin 229
		}
358 benjamin 230
 
445 benjamin 231
	}
232
 
233
	public void allerALapageSuivante() {
564 benjamin 234
		if (pageCourante < nbPage) {
445 benjamin 235
			int pageAAfficher = pageCourante + 1;
446 aurelien 236
			pageCourante = pageAAfficher;
445 benjamin 237
			chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
446 aurelien 238
			BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
445 benjamin 239
		}
240
	}
241
 
446 aurelien 242
	public void allerALaPremierePage() {
445 benjamin 243
		int pageAAfficher = 1;
446 aurelien 244
		pageCourante = pageAAfficher;
445 benjamin 245
		chargerElements(0, pas);
446 aurelien 246
		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
445 benjamin 247
	}
248
 
446 aurelien 249
	public void allerAlaDernierePage() {
564 benjamin 250
		int pageAAfficher = nbPage;
446 aurelien 251
		pageCourante = pageAAfficher;
445 benjamin 252
		chargerElements(pas * (pageAAfficher - 1), pas * (pageAAfficher));
446 aurelien 253
		BusEvenementiel.getInstance().fireEvent(new EvenementChangementPage(pageAAfficher, groupePagination));
445 benjamin 254
	}
255
 
256
	/** calcule le nombre de page en fonction du pas */
257
	private int calculerNbPage() {
258
		Double nombrePages = Math.ceil((double) nbElementsTotal / (double) pas);
259
		return nombrePages.intValue();
260
	}
261
 
262
	public void setNbPages(int nbPages) {
263
		this.nbPage = nbPages;
264
	}
265
 
266
	public int getNbPages() {
267
		return nbPage;
268
	}
269
 
270
	public Vue getVue() {
271
		return vue;
272
	}
273
 
274
	public abstract void chargerElements(int debut, int fin);
275
 
263 gduche 276
	public abstract void actualiserPasCache(int pas);
120 gduche 277
 
445 benjamin 278
	public void setPas(int pas) {
279
		this.pas = pas;
436 benjamin 280
	}
564 benjamin 281
 
446 aurelien 282
	public void setGroupePagination(String groupePagination) {
283
		this.groupePagination = groupePagination;
284
	}
564 benjamin 285
 
446 aurelien 286
	public String getGroupePagination() {
287
		return groupePagination;
288
	}
436 benjamin 289
 
566 gduche 290
	public void actualiserAffichageBoutons() {
651 gduche 291
		if (nbPage == 1) {
566 gduche 292
			vue.masquerBoutonPrecedent();
651 gduche 293
			vue.masquerBoutonSuivant();
294
		} else if (pageCourante == 1) {
295
			vue.masquerBoutonPrecedent();
566 gduche 296
			vue.afficherBoutonSuivant();
297
		} else {
298
			vue.afficherBoutonPrecedent();
299
			if (pageCourante == nbPage) {
300
				vue.masquerBoutonSuivant();
301
			}
302
		}
303
	}
120 gduche 304
}