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