Subversion Repositories eFlore/Applications.coel

Rev

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

Rev Author Line No. Line
594 gduche 1
package org.tela_botanica.client.vues;
2
 
3
import java.util.Iterator;
4
import java.util.LinkedList;
5
 
6
import org.tela_botanica.client.Mediateur;
7
import org.tela_botanica.client.images.Images;
8
import org.tela_botanica.client.interfaces.ListePaginable;
9
import org.tela_botanica.client.interfaces.Rafraichissable;
621 gduche 10
import org.tela_botanica.client.util.UtilString;
594 gduche 11
 
12
import com.extjs.gxt.ui.client.event.ButtonEvent;
13
import com.extjs.gxt.ui.client.event.ComponentEvent;
14
import com.extjs.gxt.ui.client.event.KeyListener;
15
import com.extjs.gxt.ui.client.event.SelectionChangedEvent;
16
import com.extjs.gxt.ui.client.event.SelectionChangedListener;
17
import com.extjs.gxt.ui.client.event.SelectionListener;
18
import com.extjs.gxt.ui.client.store.ListStore;
19
import com.extjs.gxt.ui.client.widget.Text;
20
import com.extjs.gxt.ui.client.widget.button.Button;
21
import com.extjs.gxt.ui.client.widget.form.SimpleComboBox;
22
import com.extjs.gxt.ui.client.widget.form.TextField;
23
import com.extjs.gxt.ui.client.widget.toolbar.FillToolItem;
24
import com.extjs.gxt.ui.client.widget.toolbar.SeparatorToolItem;
25
import com.extjs.gxt.ui.client.widget.toolbar.ToolBar;
26
import com.google.gwt.event.dom.client.KeyCodes;
27
import com.google.gwt.i18n.client.Dictionary;
28
 
29
public class BarrePaginationVue extends ToolBar implements Rafraichissable {
30
 
31
	private ListePaginable listePaginable = null;
32
 
33
	private Button prevPage, suivPage, premierePage, dernierePage, rafraichir;
34
 
35
	private int pageCourante, nbElement = 0;
36
	private int taillePage = Integer.valueOf(((Dictionary) Dictionary.getDictionary("configuration")).get("nbElementsPage"));
37
	private int pageTotale = 1;
38
	private Text page, surTotalPage, afficherNbElem, nbElemParPage, intervalleElements;
39
 
40
	private TextField<String> champPage = new TextField<String>();
41
	private SimpleComboBox selecteurTaillePage = new SimpleComboBox();
42
 
43
	LinkedList<Integer> intervallePages = new LinkedList<Integer>();
44
 
45
	ListStore storeIntervalle = new ListStore() ;
46
 
47
	private String labelElement;
48
	private int taillePageDefaut = 50;
49
 
50
	public ListePaginable getlistePaginable() {
51
		return listePaginable;
52
	}
53
 
54
	public void setlistePaginable(ListePaginable listePaginable) {
55
		this.listePaginable = listePaginable;
56
	}
57
 
58
	private Mediateur mediateur;
59
 
60
	public int valeur = 0;
61
	/***************************************************************************
62
	 * constructeur sans argument (privé car ne doit pas être utilisé)
63
	 */
64
	@SuppressWarnings("unused")
65
	private BarrePaginationVue() {
66
		super();
67
	}
68
 
69
	/**
70
	 * constructeur avec paramètres
71
	 *
72
	 * @param im
73
	 *            le médiateur à associer à la barre
74
	 */
75
	public BarrePaginationVue(ListePaginable listePaginable, Mediateur mediateur) {
76
 
77
		super();
78
 
79
		this.listePaginable = listePaginable;
80
		this.mediateur = mediateur;
81
 
82
		intervallePages.add(10);
83
		intervallePages.add(20);
84
		intervallePages.add(50);
85
		intervallePages.add(100);
86
		intervallePages.add(200);
87
 
88
		premierePage = new Button();
89
		premierePage.setIcon(Images.ICONES.resultsetFirst());
90
		add(premierePage);
91
 
92
		prevPage = new Button();
93
		prevPage.setIcon(Images.ICONES.resultsetPrevious());
94
		add(prevPage);
95
 
96
		add(new SeparatorToolItem());
97
 
98
		page = new Text(mediateur.i18nC.page());
99
		page.setStyleAttribute("padding", "0 5px 0 5px");
100
		add(page);
101
 
102
		champPage.setValue(String.valueOf(pageCourante+1));
103
		champPage.setStyleAttribute("text-align","right");
104
		champPage.setWidth(30);
105
		add(champPage);
106
 
107
		surTotalPage = new Text(mediateur.i18nC.sur() + " " + pageTotale);
108
		surTotalPage.setStyleAttribute("padding-left", "5px");
109
		add(surTotalPage);
110
 
111
		//Séparation
112
		add(new SeparatorToolItem());
113
 
114
		suivPage = new Button();
115
		suivPage.setIcon(Images.ICONES.resultsetNext());
116
		add(suivPage);
117
 
118
		dernierePage = new Button();
119
		dernierePage.setIcon(Images.ICONES.resultsetLast());
120
		add(dernierePage);
121
 
122
		//Séparation
123
		add(new SeparatorToolItem());
124
 
125
		rafraichir = new Button();
126
		rafraichir.setIcon(Images.ICONES.rafraichir());
127
		add(rafraichir);
128
 
129
		//Séparation
130
		add(new SeparatorToolItem());
131
 
132
		afficherNbElem = new Text(mediateur.i18nC.afficher());
133
		afficherNbElem.setStyleAttribute("padding", "0 5px 0 5px");
134
		add(afficherNbElem);
135
 
136
 
137
		selecteurTaillePage.setWidth("40px");
138
		setIntervallesPages();
139
		add(selecteurTaillePage);
140
 
141
		labelElement = mediateur.i18nC.elements();
142
 
143
		nbElemParPage = new Text(labelElement + " " +mediateur.i18nC.parPage());
144
		nbElemParPage.setStyleAttribute("padding-left", "5px");
145
		add(nbElemParPage);
146
 
147
		// Ajout d'un espace pour mettre le nombre d'éléments à droite
148
		add(new FillToolItem());
149
 
621 gduche 150
		intervalleElements = new Text(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 151
																	(pageCourante + 1) * taillePage, nbElement));
152
		add(intervalleElements);
153
 
154
		// on ajoute les différents listeners
155
		ajouterListeners();
156
	}
157
 
158
 
159
 
621 gduche 160
 
594 gduche 161
	/**
162
	 *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
163
	 * 	@param label
164
	 */
165
 
166
	public void setLabelElement(String label) {
167
		this.labelElement = label;
168
		nbElemParPage.setText(labelElement + " par page ");
621 gduche 169
		intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 170
				(pageCourante + 1) * taillePage, nbElement));
171
 
172
	}
173
 
174
	public void setTaillePageParDefaut(int taille) {
175
		this.taillePageDefaut = taille;
176
		selecteurTaillePage.setRawValue(""+taillePageDefaut);
177
	}
178
 
179
	public void setIntervallesPages()
180
	{
181
 
182
		if (!intervallePages.contains(taillePage))	{
183
			intervallePages.add(taillePage);
184
		}
185
 
186
		Iterator<Integer> itIntervallePages = intervallePages.iterator();
187
		while (itIntervallePages.hasNext())	{
188
			selecteurTaillePage.add(itIntervallePages.next());
189
		}
190
 
191
		selecteurTaillePage.setSimpleValue(taillePage);
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
	@SuppressWarnings("unchecked")
200
	private void ajouterListeners() {
201
 
202
		premierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
203
 
204
			public void componentSelected(ButtonEvent ce)	{
205
				pageCourante = 0;
206
				rafraichirNumeroPage();
207
				listePaginable.changerNumeroPage(pageCourante);
208
			}
209
		});
210
 
211
		// boutons suivants et précédents
212
		prevPage.addSelectionListener(new SelectionListener<ButtonEvent>() {
213
 
214
			public void componentSelected(ButtonEvent ce) {
215
							// si la page courante n'est pas la première
216
				if (pageCourante > 0) {
217
					// on décrémente la page courante de 1
218
					pageCourante--;
219
					// on rafraichit l'affichage
220
					rafraichirNumeroPage();
221
					// et on notifie le médiateur de l'évenement
222
					listePaginable.changerNumeroPage(pageCourante);
223
 
224
				}
225
			}
226
		});
227
 
228
		suivPage.addSelectionListener(new SelectionListener<ButtonEvent>() {
229
 
230
			public void componentSelected(ButtonEvent ce)	{
231
 
232
				// si la page courante n'est pas la dernière
233
				if (pageCourante < pageTotale - 1) {
234
					// on incrémente la page courante de 1
235
					pageCourante++;
236
					// on rafraichit l'affichage
237
					rafraichirNumeroPage();
238
					// et on notifie le médiateur de l'évenement
239
					listePaginable.changerNumeroPage(pageCourante);
240
				}
241
			}
242
		});
243
 
244
		dernierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
245
 
246
			public void componentSelected(ButtonEvent ce)	{
247
				pageCourante = pageTotale;
248
				rafraichirNumeroPage();
249
				listePaginable.changerNumeroPage(pageCourante);
250
			}
251
		});
252
 
253
		rafraichir.addSelectionListener(new SelectionListener<ButtonEvent>() {
254
 
255
			public void componentSelected(ButtonEvent ce)	{
256
				listePaginable.changerNumeroPage(pageCourante);
257
			}
258
		});
259
 
260
 
261
		champPage.addKeyListener(new KeyListener() {
262
 
263
			public void componentKeyUp(ComponentEvent ce) 	{
264
 
265
				// on teste si la touche entrée a été pressée
266
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
267
					int nouvellePage = pageCourante;
268
					// on teste avec parseInt si la valeur entrée est un entier
269
					try {
270
						nouvellePage = Integer
271
								.parseInt(champPage.getRawValue());
272
					}
273
					// si ce n'est pas le cas alors on remet le numéro de page
274
					// correct
275
					catch (NumberFormatException nfe) {
276
						rafraichirNumeroPage();
277
						champPage.focus();
278
						return;
279
					}
280
 
281
					// si la conversion reussit on verifie s'il est nécessaire
282
					// de changer de page
283
					// et si la nouvelle est comprise dans l'intervalle des
284
					// pages existantes (0..pageTotale)
285
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
286
							&& nouvellePage <= pageTotale) {
287
						// le cas échéant, on charge la nouvelle page et on
288
						// notifie le médiateur
289
						changerPageCourante(nouvellePage - 1);
290
						listePaginable.changerNumeroPage(pageCourante);
291
 
292
					} else {
293
						// sinon on reaffiche l'ancien numero de page sans rien
294
						// changer
295
						rafraichirNumeroPage();
296
						champPage.focus();
297
					}
298
				}
299
			}
300
 
301
		/*	public void onFocus(Field field) {
302
 
303
				champPage.focus();
304
			}*/
305
 
306
		});
307
 
308
		// pour éviter de se compliquer la vie, on filtre tous les charactères
309
		// non numériques
310
		champPage.addKeyListener(new KeyListener()	{
311
 
312
			public void componentKeyDown(ComponentEvent ce) 	{
313
 
314
				// si c'est un numerique
315
				/*
316
				FIXME
317
				if (Character.isDigit((char) e.getCharCode())) {
318
 
319
					// on laisse passer
320
					return;
321
				}*/
322
 
323
				// si c'est la touche entrée ou backspace (valider ou effacer)
324
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER
325
						|| ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {
326
					// on laisse passer
327
					return;
328
				} else {
329
					// sinon on remet le numero de page correct et on annule
330
					// l'évenement
331
					rafraichirNumeroPage();
332
					ce.stopEvent();
333
				}
334
			}
335
 
336
		});
337
 
338
		// listener pour la selection dans la combobox
339
		selecteurTaillePage.addSelectionChangedListener(
340
 
341
				new SelectionChangedListener() {
342
 
343
					public void selectionChanged(SelectionChangedEvent e)	{
344
 
345
					SimpleComboBox comboBox = (SimpleComboBox) e.getSource();
346
					String nouvelleTaillePageString = comboBox.getRawValue();
655 gduche 347
					int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString);
348
 
349
					changerTaillePage(nouvelleTaillePage);
594 gduche 350
 
655 gduche 351
					rafraichirNumeroPage();
594 gduche 352
			}
353
 
354
		});
355
	}
655 gduche 356
 
594 gduche 357
	/**
358
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
359
	 * d'éléments à partir des variables de classes
360
	 */
361
	public void rafraichirNumeroPage() {
362
 
363
		surTotalPage.setText(" sur " + pageTotale);
364
 
365
		if (nbElement == 0) {
366
			champPage.setValue("" + (0));
367
			// on met simplement à jour l'intervalle qui contient toujours le
368
			// même nombre d'éléments
621 gduche 369
			intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), 0,0,0));
594 gduche 370
		} else {
371
			champPage.setValue("" + (pageCourante + 1));
372
 
373
			// si la page n'est pas la dernière
374
			if (pageCourante + 1 != pageTotale) {
375
				// sauf pour la dernière page qui contient souvent moins
376
				// d'élements que le nombre d'élements par page
621 gduche 377
				intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 378
						(pageCourante + 1) * taillePage, nbElement));
379
			} else {
380
 
381
				// on met simplement à jour l'intervalle qui contient toujours
382
				// le même nombre d'éléments
621 gduche 383
				intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 384
						nbElement, nbElement));
385
			}
386
		}
387
	}
388
 
389
	/**
390
	 * Met à jour la page en cours
391
	 *
392
	 * @param nouvellePageCourante
393
	 *            la nouvelle page en cours
394
	 */
395
	public void changerPageCourante(int nouvellePageCourante) {
396
		pageCourante = nouvellePageCourante;
397
	}
398
 
399
	/*
400
	 * Renvoie les différents intervalles de pages possibles
401
	 *
402
	 * @return un tableau de string qui contient les différentes
403
	 *         taille de pages
404
	 *
405
	public String[] getNbPages() {
406
 
407
		return pages;
408
	}/
409
 
410
	/**
411
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
412
	 * va à son tour faire les modifications nécessaires)
413
	 *
414
	 * @param nouvelleTaillePage
415
	 *            la nouvelle taille de page (élement appartenant au tableau
416
	 *            renvoyé par getNbPages())
417
	 */
418
	public void changerTaillePage(int nouvelleTaillePage) {
655 gduche 419
		if (nouvelleTaillePage != taillePage)	{
420
			listePaginable.changerTaillePage(nouvelleTaillePage);
421
		}
594 gduche 422
	}
423
 
424
	/**
425
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
426
	 * combobox (si elle existe)
427
	 *
428
	 * @param nouvelleTaillePage
429
	 *            la nouvelle taille de page
430
	 */
431
	public void selectionnerTaillePage(int nouvelleTaillePage) {
432
 
433
		selecteurTaillePage.setRawValue("" + nouvelleTaillePage);
434
	}
435
 
436
	@Override
437
	public void rafraichir(Object nouvelleDonnees) {
438
		// si on reçoit un tableau de int
439
		if (nouvelleDonnees instanceof int[]) {
440
 
441
			int[] page = (int[]) nouvelleDonnees;
442
			// le premier élement est le nombre de pages totales
443
			pageTotale = page[0];
444
			// le second la page en cours
445
			pageCourante = page[1];
446
			// le troisième la taille de la page
447
			taillePage = page[2];
448
			// et le dernier le nombre total d'éléments
449
			nbElement = page[3];
450
 
451
			// si la page courante dépasse la page totale (cas normalement
452
			// improbable car géré en amont)
453
			// on met le numéro de page à la page courante -1 (car la page
454
			// courante est comptée à partir
455
			// de zéro)
456
			if (pageCourante >= pageTotale && pageCourante != 0) {
457
				pageCourante = pageTotale - 1;
458
				// le cas échéant on en notifie le médiateur
459
				listePaginable.changerNumeroPage(pageCourante);
460
			}
461
		}
462
 
463
		// enfin on rafraichit les informations affichées à partir des nouvelles
464
		// variables de classes mises à jour
465
		rafraichirNumeroPage();
466
 
467
		layout();
468
	}
469
 
470
}