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