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