Subversion Repositories eFlore/Applications.coel

Rev

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