Subversion Repositories eFlore/Applications.cel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
403 aurelien 1
package org.tela_botanica.client.vues;
2
 
3
import org.tela_botanica.client.interfaces.ListePaginable;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
5
 
6
import com.google.gwt.user.client.Window;
2611 aurelien 7
import com.gwtext.client.core.EventCallback;
403 aurelien 8
import com.gwtext.client.core.EventObject;
9
import com.gwtext.client.core.Template;
10
import com.gwtext.client.data.Record;
11
import com.gwtext.client.data.SimpleStore;
12
import com.gwtext.client.data.Store;
13
import com.gwtext.client.widgets.Button;
14
import com.gwtext.client.widgets.Toolbar;
15
import com.gwtext.client.widgets.ToolbarButton;
16
import com.gwtext.client.widgets.ToolbarTextItem;
17
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
18
import com.gwtext.client.widgets.form.ComboBox;
2611 aurelien 19
import com.gwtext.client.widgets.form.Field;
20
import com.gwtext.client.widgets.form.TextField;
403 aurelien 21
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
2611 aurelien 22
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
403 aurelien 23
 
24
public class MiniBarrePaginationVue extends Toolbar implements Rafraichissable {
25
 
26
	/**
27
	 * Instance du médiateur à qui on notifie les évnènements
28
	 */
29
	private ListePaginable listePaginable = null;
30
 
31
	/**
32
	 * Bouton précédent
33
	 */
34
	private ToolbarButton prevPage = new ToolbarButton();
35
	/**
36
	 * Bouton suivant
37
	 */
38
	private ToolbarButton suivPage = new ToolbarButton();
2611 aurelien 39
 
403 aurelien 40
	/**
41
	 * Numéro de la page courante (attention, commence à zéro pour des raisons
42
	 * pratiques)
43
	 */
44
	private int pageCourante = 0;
45
	/**
46
	 * Nombre de page total
47
	 */
48
	private int pageTotale = 1;
49
	/**
50
	 * Nombre d'élements total
51
	 */
52
	private int nbElement = 0;
53
	/**
54
	 * Nombre d'élément par page
55
	 */
56
	private int taillePage = 0;
57
	/**
58
	 * Texte statique de la toolbar 2
59
	 */
60
	private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ");
2611 aurelien 61
 
403 aurelien 62
	/**
2611 aurelien 63
	 * Affichage de la page courante
64
	 */
65
	private TextField champPage = new TextField("" + (pageCourante + 1));
66
 
67
	private ToolbarTextItem surPageTotale = new ToolbarTextItem("/ ");
68
 
69
	/**
403 aurelien 70
	 * Combobox permettant de selectionner le nombre d'élements à afficher par
71
	 * page et donc de changer la variable taillePage
72
	 */
73
	private ComboBox selecteurTaillePage = new ComboBox();
74
 
75
	/**
76
	 * Les différents intervalles de page possibles (intialisé par défaut)
77
	 */
2611 aurelien 78
	String[] pages = {"200","100","50", "20", "10"};
403 aurelien 79
 
80
	Store storeIntervalle = null ;
81
 
82
 
83
 
84
	/**
85
	 * Label indiquant le type d'element affiché
86
	 *
87
	 */
2611 aurelien 88
	private String labelElement="Obs";
403 aurelien 89
 
90
	/**
91
	 * taille de la page par defaut
92
	 *
93
	 */
94
	private int taillePageDefaut = 50;
95
 
96
 
97
	/**
98
	 * Texte statique de la toolbar 3
99
	 */
2611 aurelien 100
	private ToolbarTextItem nbElemParPage = new ToolbarTextItem(labelElement);
403 aurelien 101
 
102
	/**
103
	 * retourne la liste associé à la barre
104
	 */
105
	public ListePaginable getlistePaginable() {
106
		return listePaginable;
107
	}
108
 
109
	/***************************************************************************
110
	 * constructeur sans argument (privé car ne doit pas être utilisé)
111
	 */
112
	@SuppressWarnings("unused")
113
	private MiniBarrePaginationVue() {
114
		super();
115
	}
116
 
117
	/**
118
	 * constructeur avec paramètres
119
	 *
120
	 * @param im
121
	 *            le médiateur à associer à la barre
122
	 */
123
	public MiniBarrePaginationVue(ListePaginable lst) {
124
		super();
125
 
126
		listePaginable = lst;
127
 
128
		// on dispose un peu de texte et quelques espaces pour séparer les
129
		// éléments
130
		addButton(prevPage);
2611 aurelien 131
		addField(champPage);
132
		addItem(surPageTotale);
403 aurelien 133
		addButton(suivPage);
134
 
135
		addSpacer();
136
		addItem(afficherNbElem);
137
 
138
		prevPage.setIcon("page_prev.png");
139
		suivPage.setIcon("page_suiv.png");
140
 
141
		setIntervallesPages(pages) ;
142
 
143
		// le template definit ce que l'on affiche pour chaque element du store
144
		// dans la combobox
145
		final Template tp = new Template("<div class=\"x-combo-list-item\">"
146
				+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
147
		tp.compile();
148
 
149
		selecteurTaillePage.setTpl(tp);
150
		selecteurTaillePage.setStore(storeIntervalle);
151
		selecteurTaillePage.setEditable(false);
152
		addField(selecteurTaillePage);
153
		selecteurTaillePage.setValue(""+taillePageDefaut);
154
		selecteurTaillePage.setWidth(50);
2611 aurelien 155
		champPage.setWidth(20);
406 aurelien 156
 
403 aurelien 157
		addItem(nbElemParPage);
158
 
159
		// on ajoute les différents listeners
160
		ajouterListeners();
161
	}
162
 
163
 
164
	/**
165
	 *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
166
	 * 	@param label
167
	 */
168
	public void setLabelElement(String label) {
169
		this.labelElement = label;
170
		nbElemParPage.setText(labelElement + " par page ");
171
	}
172
 
173
	public void setTaillePageParDefaut(int taille) {
174
		this.taillePageDefaut = taille;
175
		selecteurTaillePage.setValue(""+taillePageDefaut);
176
	}
177
 
178
	public void setIntervallesPages(String[] intervalle)
179
	{
180
		String[][] intervallesPages = new String[intervalle.length][1] ;
181
 
182
		for(int i = 0 ; i < intervalle.length ; i++)
183
		{
184
			intervallesPages[i][0] = intervalle[i] ;
185
		}
186
 
187
		storeIntervalle = new SimpleStore(new String[] { "nb_page" },
188
				intervallesPages );
189
		storeIntervalle.load();
190
		selecteurTaillePage.setStore(storeIntervalle);
191
	}
192
 
193
 
194
	/**
195
	 * ajoute les différents listeners nécessaires au bon fonctionnement des
196
	 * éléments de la barre de pagination
197
	 */
198
	private void ajouterListeners() {
199
		// boutons suivants et précédents
200
		prevPage.addListener(new ButtonListenerAdapter() {
201
 
1291 aurelien 202
			@Override
403 aurelien 203
			public void onClick(Button button, EventObject e) {
204
 
205
				// si la page courante n'est pas la première
206
				if (pageCourante > 0) {
207
					// on décrémente la page courante de 1
208
					pageCourante--;
209
					// on rafraichit l'affichage
210
					// et on notifie le médiateur de l'évenement
211
					listePaginable.changerNumeroPage(pageCourante);
212
 
213
				}
214
			}
215
		});
216
 
217
		suivPage.addListener(new ButtonListenerAdapter() {
218
 
1291 aurelien 219
			@Override
403 aurelien 220
			public void onClick(Button button, EventObject e) {
406 aurelien 221
 
403 aurelien 222
				// si la page courante n'est pas la dernière
223
				if (pageCourante < pageTotale - 1) {
224
					// on incrémente la page courante de 1
225
					pageCourante++;
226
					// on rafraichit l'affichage
227
					// et on notifie le médiateur de l'évenement
228
					listePaginable.changerNumeroPage(pageCourante);
229
 
230
				}
231
			}
232
		});
233
 
234
		// listener pour la selection dans la combobox
235
		selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
236
 
1291 aurelien 237
			@Override
403 aurelien 238
			public void onSelect(ComboBox comboBox, Record record, int index) {
239
 
240
				String nouvelleTaillePageString = comboBox.getStore()
241
						.getRecordAt(index).getAsString("nb_page");
242
				int nouvelleTaillePage = Integer
243
						.parseInt(nouvelleTaillePageString);
244
 
245
				// si la taille de page est différente de l'ancienne
246
				if (nouvelleTaillePage != taillePage) {
247
					// on la change
248
					changerTaillePage(nouvelleTaillePage);
249
				}
250
				// et on met la valeur à jour dans la combobox
251
				comboBox.setValue(nouvelleTaillePageString);
252
			}
253
 
254
		});
2611 aurelien 255
 
256
		champPage.addListener(new TextFieldListenerAdapter() {
257
 
258
			@Override
259
			public void onSpecialKey(Field field, EventObject e) {
260
 
261
				// on teste si la touche entrée a été pressée
262
				if (e.getKey() == EventObject.ENTER) {
263
					int nouvellePage = pageCourante;
264
					// on teste avec parseInt si la valeur entrée est un entier
265
					try {
266
						nouvellePage = Integer
267
								.parseInt(champPage.getRawValue());
268
					}
269
					// si ce n'est pas le cas alors on remet le numéro de page
270
					// correct
271
					catch (NumberFormatException nfe) {
272
						rafraichirNumeroPage();
273
						champPage.focus(true);
274
						return;
275
					}
276
 
277
					// si la conversion reussit on verifie s'il est nécessaire
278
					// de changer de page
279
					// et si la nouvelle est comprise dans l'intervalle des
280
					// pages existantes (0..pageTotale)
281
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
282
							&& nouvellePage <= pageTotale) {
283
						// le cas échéant, on charge la nouvelle page et on
284
						// notifie le médiateur
285
						changerPageCourante(nouvellePage - 1);
286
						listePaginable.changerNumeroPage(pageCourante);
287
 
288
					} else {
289
						// sinon on reaffiche l'ancien numero de page sans rien
290
						// changer
291
						rafraichirNumeroPage();
292
						champPage.focus(true);
293
					}
294
				}
295
			}
296
 
297
			@Override
298
			public void onFocus(Field field) {
299
 
300
				champPage.focus(true);
301
			}
302
 
303
		});
304
 
305
		// pour éviter de se compliquer la vie, on filtre tous les charactères
306
		// non numériques
307
		champPage.addKeyPressListener(new EventCallback() {
308
 
309
			@Override
310
			public void execute(EventObject e) {
311
 
312
				// si c'est un numerique
313
				if (Character.isDigit((char) e.getCharCode())) {
314
					// on laisse passer
315
					return;
316
				}
317
 
318
				// si c'est la touche entrée ou backspace (valider ou effacer)
319
				if (e.getKey() == EventObject.ENTER
320
						|| e.getKey() == EventObject.BACKSPACE) {
321
					// on laisse passer
322
					return;
323
				} else {
324
					// sinon on remet le numero de page correct et on annule
325
					// l'évenement
326
					rafraichirNumeroPage();
327
					e.stopEvent();
328
				}
329
			}
330
 
331
		});
403 aurelien 332
	}
333
 
334
	/**
335
	 * Met à jour la page en cours
336
	 *
337
	 * @param nouvellePageCourante
338
	 *            la nouvelle page en cours
339
	 */
340
	public void changerPageCourante(int nouvellePageCourante) {
341
		pageCourante = nouvellePageCourante;
342
	}
343
 
344
	/**
345
	 * Methode héritée de l'interface rafraichissable
346
	 */
1291 aurelien 347
	@Override
403 aurelien 348
	public void rafraichir(Object nouvelleDonnees,
349
			boolean repandreRaffraichissement) {
350
 
351
		// si on reçoit un tableau de int
352
		if (nouvelleDonnees instanceof int[]) {
353
			int[] page = (int[]) nouvelleDonnees;
354
			// le premier élement est le nombre de pages totales
355
			pageTotale = page[0];
356
			// le second la page en cours
357
			pageCourante = page[1];
358
			// le troisième la taille de la page
359
			taillePage = page[2];
360
			// et le dernier le nombre total d'éléments
361
			nbElement = page[3];
362
 
363
			// si la page courante dépasse la page totale (cas normalement
364
			// improbable car géré en amont)
365
			// on met le numéro de page à la page courante -1 (car la page
366
			// courante est comptée à partir
367
			// de zéro)
368
			if (pageCourante >= pageTotale && pageCourante != 0) {
369
				pageCourante = pageTotale - 1;
370
				// le cas échéant on en notifie le médiateur
371
				listePaginable.changerNumeroPage(pageCourante);
372
			}
2611 aurelien 373
 
374
			rafraichirNumeroPage();
403 aurelien 375
		}
376
	}
377
 
378
	/**
379
	 * Renvoie les différents intervalles de pages possibles
380
	 *
381
	 * @return un tableau de string qui contient les différentes
382
	 *         taille de pages
383
	 */
384
	public String[] getNbPages() {
385
		return pages;
386
	}
387
 
388
	/**
389
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
390
	 * va à son tour faire les modifications nécessaires)
391
	 *
392
	 * @param nouvelleTaillePage
393
	 *            la nouvelle taille de page (élement appartenant au tableau
394
	 *            renvoyé par getNbPages())
395
	 */
396
	public void changerTaillePage(int nouvelleTaillePage) {
397
		listePaginable.changerTaillePage(nouvelleTaillePage);
398
	}
399
 
400
	/**
401
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
402
	 * combobox (si elle existe)
403
	 *
404
	 * @param nouvelleTaillePage
405
	 *            la nouvelle taille de page
406
	 */
407
	public void selectionnerTaillePage(int nouvelleTaillePage) {
408
		selecteurTaillePage.setValue("" + nouvelleTaillePage);
409
	}
2611 aurelien 410
 
411
	/**
412
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
413
	 * d'éléments à partir des variables de classes
414
	 */
415
	public void rafraichirNumeroPage() {
416
		if (nbElement == 0) {
417
			champPage.setValue("" + (0));
418
		} else {
419
			champPage.setValue("" + (pageCourante + 1));
420
		}
421
		surPageTotale.setText("/"+pageTotale);
422
	}
403 aurelien 423
}