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