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