Subversion Repositories eFlore/Applications.coel

Rev

Rev 1136 | 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;
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 {
1126 jpm 323
						nouvellePage = Integer.parseInt(champPage.getRawValue());
324
					} catch (NumberFormatException nfe) {
325
						// si ce n'est pas le cas alors on remet le numéro de page correct
594 gduche 326
						rafraichirNumeroPage();
327
						champPage.focus();
328
						return;
329
					}
330
 
331
					// si la conversion reussit on verifie s'il est nécessaire
332
					// de changer de page
333
					// et si la nouvelle est comprise dans l'intervalle des
334
					// pages existantes (0..pageTotale)
335
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
336
							&& nouvellePage <= pageTotale) {
337
						// le cas échéant, on charge la nouvelle page et on
338
						// notifie le médiateur
339
						changerPageCourante(nouvellePage - 1);
340
						listePaginable.changerNumeroPage(pageCourante);
341
					} else {
342
						// sinon on reaffiche l'ancien numero de page sans rien
343
						// changer
344
						rafraichirNumeroPage();
345
						champPage.focus();
346
					}
347
				}
1125 jpm 348
			}
594 gduche 349
		});
350
 
351
		// pour éviter de se compliquer la vie, on filtre tous les charactères
352
		// non numériques
1125 jpm 353
		champPage.addKeyListener(new KeyListener() {
354
			public void componentKeyDown(ComponentEvent ce) {
1126 jpm 355
				// FIXME : si c'est un numerique
356
				/*if (Character.isDigit((char) e.getCharCode())) {
594 gduche 357
					// on laisse passer
358
					return;
359
				}*/
360
 
361
				// si c'est la touche entrée ou backspace (valider ou effacer)
362
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER
363
						|| ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {
364
					// on laisse passer
365
					return;
366
				} else {
1126 jpm 367
					// sinon on remet le numero de page correct et on annule l'évenement
594 gduche 368
					rafraichirNumeroPage();
369
					ce.stopEvent();
370
				}
371
			}
372
		});
373
 
374
		// listener pour la selection dans la combobox
1125 jpm 375
		selecteurTaillePage.addSelectionChangedListener(new SelectionChangedListener() {
376
			public void selectionChanged(SelectionChangedEvent e) {
377
				SimpleComboBox comboBox = (SimpleComboBox) e.getSource();
378
				String nouvelleTaillePageString = comboBox.getRawValue();
379
				int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString);
380
				changerTaillePage(nouvelleTaillePage);
381
				rafraichirNumeroPage();
594 gduche 382
			}
383
		});
384
	}
655 gduche 385
 
594 gduche 386
	/**
387
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
388
	 * d'éléments à partir des variables de classes
389
	 */
390
	public void rafraichirNumeroPage() {
1125 jpm 391
		if (filtreActive == true) {
1059 gduche 392
			intervalleElements.setText("<b><i>Recherche active : </i></b>" + termeRecherche);
594 gduche 393
		} else {
1040 gduche 394
			surTotalPage.setText(" sur " + pageTotale);
395
			if (nbElement == 0) {
396
				champPage.setValue("" + (0));
397
				// on met simplement à jour l'intervalle qui contient toujours le
398
				// même nombre d'éléments
1125 jpm 399
				intervalleElements.setText(i18nM.elementsAffiches(UtilString.ucFirst(labelElement), 0,0,0));
594 gduche 400
			} else {
1040 gduche 401
				champPage.setValue("" + (pageCourante + 1));
402
				// si la page n'est pas la dernière
403
				if (pageCourante + 1 != pageTotale) {
404
					// sauf pour la dernière page qui contient souvent moins
405
					// d'élements que le nombre d'élements par page
1125 jpm 406
					intervalleElements.setText(i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
1040 gduche 407
							(pageCourante + 1) * taillePage, nbElement));
408
				} else {
409
 
410
					// on met simplement à jour l'intervalle qui contient toujours
411
					// le même nombre d'éléments
1125 jpm 412
					intervalleElements.setText(i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
1040 gduche 413
							nbElement, nbElement));
414
				}
594 gduche 415
			}
416
		}
417
	}
418
 
419
	/**
420
	 * Met à jour la page en cours
421
	 *
422
	 * @param nouvellePageCourante
423
	 *            la nouvelle page en cours
424
	 */
425
	public void changerPageCourante(int nouvellePageCourante) {
426
		pageCourante = nouvellePageCourante;
427
	}
428
 
429
	/**
430
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
431
	 * va à son tour faire les modifications nécessaires)
432
	 *
433
	 * @param nouvelleTaillePage
434
	 *            la nouvelle taille de page (élement appartenant au tableau
435
	 *            renvoyé par getNbPages())
436
	 */
437
	public void changerTaillePage(int nouvelleTaillePage) {
655 gduche 438
		if (nouvelleTaillePage != taillePage)	{
439
			listePaginable.changerTaillePage(nouvelleTaillePage);
440
		}
594 gduche 441
	}
442
 
443
	/**
444
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
445
	 * combobox (si elle existe)
446
	 *
447
	 * @param nouvelleTaillePage
448
	 *            la nouvelle taille de page
449
	 */
450
	public void selectionnerTaillePage(int nouvelleTaillePage) {
451
		selecteurTaillePage.setRawValue("" + nouvelleTaillePage);
452
	}
453
 
454
	public void rafraichir(Object nouvelleDonnees) {
455
		// si on reçoit un tableau de int
456
		if (nouvelleDonnees instanceof int[]) {
457
			int[] page = (int[]) nouvelleDonnees;
458
			// le premier élement est le nombre de pages totales
459
			pageTotale = page[0];
460
			// le second la page en cours
461
			pageCourante = page[1];
462
			// le troisième la taille de la page
463
			taillePage = page[2];
464
			// et le dernier le nombre total d'éléments
465
			nbElement = page[3];
466
 
467
			// si la page courante dépasse la page totale (cas normalement
468
			// improbable car géré en amont)
469
			// on met le numéro de page à la page courante -1 (car la page
470
			// courante est comptée à partir
471
			// de zéro)
472
			if (pageCourante >= pageTotale && pageCourante != 0) {
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
	}
1125 jpm 485
}