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