Subversion Repositories eFlore/Applications.coel

Rev

Rev 1040 | Rev 1060 | 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;
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");
1040 gduche 310
			}
311
		});
312
 
313
		filtre.addKeyListener(new KeyListener(){
314
			public void componentKeyUp(ComponentEvent ce) 	{
315
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
316
 
317
					termeRecherche = filtre.getValue();
318
					if (termeRecherche == null || termeRecherche.equals(""))	{
319
						filtreActive = false;
1059 gduche 320
						labelFiltre.setStyleAttribute("font-weight", "normal");
1040 gduche 321
						listePaginable.changerNumeroPage(pageCourante);
1059 gduche 322
						changerEtatBarre(true);
1040 gduche 323
					} else	{
1059 gduche 324
						changerEtatBarre(false);
1040 gduche 325
						listePaginable.filtrerParNom(termeRecherche);
1059 gduche 326
						labelFiltre.setStyleAttribute("font-weight", "bold");
1040 gduche 327
						filtreActive = true;
328
					}
329
				}
330
			}
331
		});
332
 
594 gduche 333
		champPage.addKeyListener(new KeyListener() {
334
 
335
			public void componentKeyUp(ComponentEvent ce) 	{
336
 
337
				// on teste si la touche entrée a été pressée
338
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
339
					int nouvellePage = pageCourante;
340
					// on teste avec parseInt si la valeur entrée est un entier
341
					try {
342
						nouvellePage = Integer
343
								.parseInt(champPage.getRawValue());
344
					}
345
					// si ce n'est pas le cas alors on remet le numéro de page
346
					// correct
347
					catch (NumberFormatException nfe) {
348
						rafraichirNumeroPage();
349
						champPage.focus();
350
						return;
351
					}
352
 
353
					// si la conversion reussit on verifie s'il est nécessaire
354
					// de changer de page
355
					// et si la nouvelle est comprise dans l'intervalle des
356
					// pages existantes (0..pageTotale)
357
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
358
							&& nouvellePage <= pageTotale) {
359
						// le cas échéant, on charge la nouvelle page et on
360
						// notifie le médiateur
361
						changerPageCourante(nouvellePage - 1);
362
						listePaginable.changerNumeroPage(pageCourante);
363
 
364
					} else {
365
						// sinon on reaffiche l'ancien numero de page sans rien
366
						// changer
367
						rafraichirNumeroPage();
368
						champPage.focus();
369
					}
370
				}
1040 gduche 371
	}
594 gduche 372
 
1040 gduche 373
 
594 gduche 374
		/*	public void onFocus(Field field) {
375
 
376
				champPage.focus();
377
			}*/
378
 
379
		});
380
 
381
		// pour éviter de se compliquer la vie, on filtre tous les charactères
382
		// non numériques
383
		champPage.addKeyListener(new KeyListener()	{
384
 
385
			public void componentKeyDown(ComponentEvent ce) 	{
386
 
387
				// si c'est un numerique
388
				/*
389
				FIXME
390
				if (Character.isDigit((char) e.getCharCode())) {
391
 
392
					// on laisse passer
393
					return;
394
				}*/
395
 
396
				// si c'est la touche entrée ou backspace (valider ou effacer)
397
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER
398
						|| ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {
399
					// on laisse passer
400
					return;
401
				} else {
402
					// sinon on remet le numero de page correct et on annule
403
					// l'évenement
404
					rafraichirNumeroPage();
405
					ce.stopEvent();
406
				}
407
			}
408
 
409
		});
410
 
411
		// listener pour la selection dans la combobox
412
		selecteurTaillePage.addSelectionChangedListener(
413
 
414
				new SelectionChangedListener() {
415
 
416
					public void selectionChanged(SelectionChangedEvent e)	{
417
 
418
					SimpleComboBox comboBox = (SimpleComboBox) e.getSource();
419
					String nouvelleTaillePageString = comboBox.getRawValue();
655 gduche 420
					int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString);
421
 
422
					changerTaillePage(nouvelleTaillePage);
594 gduche 423
 
655 gduche 424
					rafraichirNumeroPage();
594 gduche 425
			}
426
 
427
		});
428
	}
655 gduche 429
 
594 gduche 430
	/**
431
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
432
	 * d'éléments à partir des variables de classes
433
	 */
434
	public void rafraichirNumeroPage() {
435
 
1040 gduche 436
		if (filtreActive == true)	{
1059 gduche 437
			intervalleElements.setText("<b><i>Recherche active : </i></b>" + termeRecherche);
594 gduche 438
		} else {
1040 gduche 439
 
440
			surTotalPage.setText(" sur " + pageTotale);
441
 
442
			if (nbElement == 0) {
443
				champPage.setValue("" + (0));
444
				// on met simplement à jour l'intervalle qui contient toujours le
445
				// même nombre d'éléments
446
				intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), 0,0,0));
594 gduche 447
			} else {
1040 gduche 448
				champPage.setValue("" + (pageCourante + 1));
449
 
450
				// si la page n'est pas la dernière
451
				if (pageCourante + 1 != pageTotale) {
452
					// sauf pour la dernière page qui contient souvent moins
453
					// d'élements que le nombre d'élements par page
454
					intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
455
							(pageCourante + 1) * taillePage, nbElement));
456
				} else {
457
 
458
					// on met simplement à jour l'intervalle qui contient toujours
459
					// le même nombre d'éléments
460
					intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
461
							nbElement, nbElement));
462
				}
594 gduche 463
			}
464
		}
465
	}
466
 
467
	/**
468
	 * Met à jour la page en cours
469
	 *
470
	 * @param nouvellePageCourante
471
	 *            la nouvelle page en cours
472
	 */
473
	public void changerPageCourante(int nouvellePageCourante) {
474
		pageCourante = nouvellePageCourante;
475
	}
476
 
477
	/*
478
	 * Renvoie les différents intervalles de pages possibles
479
	 *
480
	 * @return un tableau de string qui contient les différentes
481
	 *         taille de pages
482
	 *
483
	public String[] getNbPages() {
484
 
485
		return pages;
486
	}/
487
 
488
	/**
489
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
490
	 * va à son tour faire les modifications nécessaires)
491
	 *
492
	 * @param nouvelleTaillePage
493
	 *            la nouvelle taille de page (élement appartenant au tableau
494
	 *            renvoyé par getNbPages())
495
	 */
496
	public void changerTaillePage(int nouvelleTaillePage) {
655 gduche 497
		if (nouvelleTaillePage != taillePage)	{
498
			listePaginable.changerTaillePage(nouvelleTaillePage);
499
		}
594 gduche 500
	}
501
 
502
	/**
503
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
504
	 * combobox (si elle existe)
505
	 *
506
	 * @param nouvelleTaillePage
507
	 *            la nouvelle taille de page
508
	 */
509
	public void selectionnerTaillePage(int nouvelleTaillePage) {
510
 
511
		selecteurTaillePage.setRawValue("" + nouvelleTaillePage);
512
	}
513
 
514
	@Override
515
	public void rafraichir(Object nouvelleDonnees) {
516
		// si on reçoit un tableau de int
517
		if (nouvelleDonnees instanceof int[]) {
518
 
519
			int[] page = (int[]) nouvelleDonnees;
520
			// le premier élement est le nombre de pages totales
521
			pageTotale = page[0];
522
			// le second la page en cours
523
			pageCourante = page[1];
524
			// le troisième la taille de la page
525
			taillePage = page[2];
526
			// et le dernier le nombre total d'éléments
527
			nbElement = page[3];
528
 
529
			// si la page courante dépasse la page totale (cas normalement
530
			// improbable car géré en amont)
531
			// on met le numéro de page à la page courante -1 (car la page
532
			// courante est comptée à partir
533
			// de zéro)
534
			if (pageCourante >= pageTotale && pageCourante != 0) {
535
				pageCourante = pageTotale - 1;
536
				// le cas échéant on en notifie le médiateur
537
				listePaginable.changerNumeroPage(pageCourante);
538
			}
539
		}
540
 
541
		// enfin on rafraichit les informations affichées à partir des nouvelles
542
		// variables de classes mises à jour
543
		rafraichirNumeroPage();
544
 
545
		layout();
546
	}
547
 
548
}