Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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