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
 
149
		nbElemParPage = new Text(labelElement + " " +mediateur.i18nC.parPage());
150
		nbElemParPage.setStyleAttribute("padding-left", "5px");
151
		add(nbElemParPage);
152
 
153
		// Ajout d'un espace pour mettre le nombre d'éléments à droite
1040 gduche 154
		labelFiltre = new Text("Recherche rapide : ");
155
		labelFiltre.setStyleAttribute("padding-left", "15px");
156
		labelFiltre.setStyleAttribute("padding-right", "5px");
157
		add(labelFiltre);
158
 
159
		filtre = new TextField<String>();
160
		filtre.setWidth(150);
161
		this.add(filtre);
162
 
163
		annulerFiltre = new Button();
164
		annulerFiltre.setIcon(Images.ICONES.annuler());
165
		add(annulerFiltre);
166
 
594 gduche 167
		add(new FillToolItem());
168
 
621 gduche 169
		intervalleElements = new Text(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 170
																	(pageCourante + 1) * taillePage, nbElement));
171
		add(intervalleElements);
172
 
173
		// on ajoute les différents listeners
174
		ajouterListeners();
1040 gduche 175
 
176
 
594 gduche 177
	}
178
 
179
 
180
 
621 gduche 181
 
1040 gduche 182
 
183
 
594 gduche 184
	/**
185
	 *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
186
	 * 	@param label
187
	 */
188
 
189
	public void setLabelElement(String label) {
190
		this.labelElement = label;
191
		nbElemParPage.setText(labelElement + " par page ");
621 gduche 192
		intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
594 gduche 193
				(pageCourante + 1) * taillePage, nbElement));
194
 
195
	}
196
 
197
	public void setTaillePageParDefaut(int taille) {
198
		this.taillePageDefaut = taille;
199
		selecteurTaillePage.setRawValue(""+taillePageDefaut);
200
	}
201
 
202
	public void setIntervallesPages()
203
	{
204
 
205
		if (!intervallePages.contains(taillePage))	{
206
			intervallePages.add(taillePage);
207
		}
208
 
209
		Iterator<Integer> itIntervallePages = intervallePages.iterator();
210
		while (itIntervallePages.hasNext())	{
211
			selecteurTaillePage.add(itIntervallePages.next());
212
		}
213
 
214
		selecteurTaillePage.setSimpleValue(taillePage);
215
	}
216
 
217
 
218
	/**
219
	 * ajoute les différents listeners nécessaires au bon fonctionnement des
220
	 * éléments de la barre de pagination
221
	 */
222
	@SuppressWarnings("unchecked")
223
	private void ajouterListeners() {
224
 
225
		premierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
226
 
227
			public void componentSelected(ButtonEvent ce)	{
228
				pageCourante = 0;
229
				rafraichirNumeroPage();
230
				listePaginable.changerNumeroPage(pageCourante);
231
			}
232
		});
233
 
234
		// boutons suivants et précédents
235
		prevPage.addSelectionListener(new SelectionListener<ButtonEvent>() {
236
 
237
			public void componentSelected(ButtonEvent ce) {
238
							// si la page courante n'est pas la première
239
				if (pageCourante > 0) {
240
					// on décrémente la page courante de 1
241
					pageCourante--;
242
					// on rafraichit l'affichage
243
					rafraichirNumeroPage();
244
					// et on notifie le médiateur de l'évenement
245
					listePaginable.changerNumeroPage(pageCourante);
246
 
247
				}
248
			}
249
		});
250
 
251
		suivPage.addSelectionListener(new SelectionListener<ButtonEvent>() {
252
 
253
			public void componentSelected(ButtonEvent ce)	{
254
 
255
				// si la page courante n'est pas la dernière
256
				if (pageCourante < pageTotale - 1) {
257
					// on incrémente la page courante de 1
258
					pageCourante++;
259
					// on rafraichit l'affichage
260
					rafraichirNumeroPage();
261
					// et on notifie le médiateur de l'évenement
262
					listePaginable.changerNumeroPage(pageCourante);
263
				}
264
			}
265
		});
266
 
267
		dernierePage.addSelectionListener(new SelectionListener<ButtonEvent>() {
268
 
269
			public void componentSelected(ButtonEvent ce)	{
270
				pageCourante = pageTotale;
271
				rafraichirNumeroPage();
272
				listePaginable.changerNumeroPage(pageCourante);
273
			}
274
		});
275
 
276
		rafraichir.addSelectionListener(new SelectionListener<ButtonEvent>() {
277
 
278
			public void componentSelected(ButtonEvent ce)	{
279
				listePaginable.changerNumeroPage(pageCourante);
280
			}
281
		});
1040 gduche 282
 
283
		annulerFiltre.addSelectionListener(new SelectionListener<ButtonEvent>() {
284
 
285
			public void componentSelected(ButtonEvent ce)	{
286
				filtre.setValue("");
287
				termeRecherche = "";
288
				filtreActive = false;
289
				listePaginable.changerNumeroPage(pageCourante);
290
			}
291
		});
292
 
293
		filtre.addKeyListener(new KeyListener(){
294
			public void componentKeyUp(ComponentEvent ce) 	{
295
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
296
 
297
					System.out.println(pageCourante +" ---- " + nbElement);
298
					termeRecherche = filtre.getValue();
299
					if (termeRecherche == null || termeRecherche.equals(""))	{
300
						filtreActive = false;
301
						listePaginable.changerNumeroPage(pageCourante);
302
					} else	{
303
						listePaginable.filtrerParNom(termeRecherche);
304
						filtreActive = true;
305
					}
306
				}
307
			}
308
		});
309
 
594 gduche 310
		champPage.addKeyListener(new KeyListener() {
311
 
312
			public void componentKeyUp(ComponentEvent ce) 	{
313
 
314
				// on teste si la touche entrée a été pressée
315
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER) {
316
					int nouvellePage = pageCourante;
317
					// on teste avec parseInt si la valeur entrée est un entier
318
					try {
319
						nouvellePage = Integer
320
								.parseInt(champPage.getRawValue());
321
					}
322
					// si ce n'est pas le cas alors on remet le numéro de page
323
					// correct
324
					catch (NumberFormatException nfe) {
325
						rafraichirNumeroPage();
326
						champPage.focus();
327
						return;
328
					}
329
 
330
					// si la conversion reussit on verifie s'il est nécessaire
331
					// de changer de page
332
					// et si la nouvelle est comprise dans l'intervalle des
333
					// pages existantes (0..pageTotale)
334
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
335
							&& nouvellePage <= pageTotale) {
336
						// le cas échéant, on charge la nouvelle page et on
337
						// notifie le médiateur
338
						changerPageCourante(nouvellePage - 1);
339
						listePaginable.changerNumeroPage(pageCourante);
340
 
341
					} else {
342
						// sinon on reaffiche l'ancien numero de page sans rien
343
						// changer
344
						rafraichirNumeroPage();
345
						champPage.focus();
346
					}
347
				}
1040 gduche 348
	}
594 gduche 349
 
1040 gduche 350
 
594 gduche 351
		/*	public void onFocus(Field field) {
352
 
353
				champPage.focus();
354
			}*/
355
 
356
		});
357
 
358
		// pour éviter de se compliquer la vie, on filtre tous les charactères
359
		// non numériques
360
		champPage.addKeyListener(new KeyListener()	{
361
 
362
			public void componentKeyDown(ComponentEvent ce) 	{
363
 
364
				// si c'est un numerique
365
				/*
366
				FIXME
367
				if (Character.isDigit((char) e.getCharCode())) {
368
 
369
					// on laisse passer
370
					return;
371
				}*/
372
 
373
				// si c'est la touche entrée ou backspace (valider ou effacer)
374
				if (ce.getKeyCode() == KeyCodes.KEY_ENTER
375
						|| ce.getKeyCode() == KeyCodes.KEY_BACKSPACE) {
376
					// on laisse passer
377
					return;
378
				} else {
379
					// sinon on remet le numero de page correct et on annule
380
					// l'évenement
381
					rafraichirNumeroPage();
382
					ce.stopEvent();
383
				}
384
			}
385
 
386
		});
387
 
388
		// listener pour la selection dans la combobox
389
		selecteurTaillePage.addSelectionChangedListener(
390
 
391
				new SelectionChangedListener() {
392
 
393
					public void selectionChanged(SelectionChangedEvent e)	{
394
 
395
					SimpleComboBox comboBox = (SimpleComboBox) e.getSource();
396
					String nouvelleTaillePageString = comboBox.getRawValue();
655 gduche 397
					int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString);
398
 
399
					changerTaillePage(nouvelleTaillePage);
594 gduche 400
 
655 gduche 401
					rafraichirNumeroPage();
594 gduche 402
			}
403
 
404
		});
405
	}
655 gduche 406
 
594 gduche 407
	/**
408
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
409
	 * d'éléments à partir des variables de classes
410
	 */
411
	public void rafraichirNumeroPage() {
412
 
1040 gduche 413
		if (filtreActive == true)	{
414
			intervalleElements.setText("<i>Recherche rapide : </i>" + termeRecherche);
594 gduche 415
		} else {
1040 gduche 416
 
417
			surTotalPage.setText(" sur " + pageTotale);
418
 
419
			if (nbElement == 0) {
420
				champPage.setValue("" + (0));
421
				// on met simplement à jour l'intervalle qui contient toujours le
422
				// même nombre d'éléments
423
				intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), 0,0,0));
594 gduche 424
			} else {
1040 gduche 425
				champPage.setValue("" + (pageCourante + 1));
426
 
427
				// si la page n'est pas la dernière
428
				if (pageCourante + 1 != pageTotale) {
429
					// sauf pour la dernière page qui contient souvent moins
430
					// d'élements que le nombre d'élements par page
431
					intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
432
							(pageCourante + 1) * taillePage, nbElement));
433
				} else {
434
 
435
					// on met simplement à jour l'intervalle qui contient toujours
436
					// le même nombre d'éléments
437
					intervalleElements.setText(mediateur.i18nM.elementsAffiches(UtilString.ucFirst(labelElement), pageCourante * taillePage,
438
							nbElement, nbElement));
439
				}
594 gduche 440
			}
441
		}
442
	}
443
 
444
	/**
445
	 * Met à jour la page en cours
446
	 *
447
	 * @param nouvellePageCourante
448
	 *            la nouvelle page en cours
449
	 */
450
	public void changerPageCourante(int nouvellePageCourante) {
451
		pageCourante = nouvellePageCourante;
452
	}
453
 
454
	/*
455
	 * Renvoie les différents intervalles de pages possibles
456
	 *
457
	 * @return un tableau de string qui contient les différentes
458
	 *         taille de pages
459
	 *
460
	public String[] getNbPages() {
461
 
462
		return pages;
463
	}/
464
 
465
	/**
466
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
467
	 * va à son tour faire les modifications nécessaires)
468
	 *
469
	 * @param nouvelleTaillePage
470
	 *            la nouvelle taille de page (élement appartenant au tableau
471
	 *            renvoyé par getNbPages())
472
	 */
473
	public void changerTaillePage(int nouvelleTaillePage) {
655 gduche 474
		if (nouvelleTaillePage != taillePage)	{
475
			listePaginable.changerTaillePage(nouvelleTaillePage);
476
		}
594 gduche 477
	}
478
 
479
	/**
480
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
481
	 * combobox (si elle existe)
482
	 *
483
	 * @param nouvelleTaillePage
484
	 *            la nouvelle taille de page
485
	 */
486
	public void selectionnerTaillePage(int nouvelleTaillePage) {
487
 
488
		selecteurTaillePage.setRawValue("" + nouvelleTaillePage);
489
	}
490
 
491
	@Override
492
	public void rafraichir(Object nouvelleDonnees) {
493
		// si on reçoit un tableau de int
494
		if (nouvelleDonnees instanceof int[]) {
495
 
496
			int[] page = (int[]) nouvelleDonnees;
497
			// le premier élement est le nombre de pages totales
498
			pageTotale = page[0];
499
			// le second la page en cours
500
			pageCourante = page[1];
501
			// le troisième la taille de la page
502
			taillePage = page[2];
503
			// et le dernier le nombre total d'éléments
504
			nbElement = page[3];
505
 
506
			// si la page courante dépasse la page totale (cas normalement
507
			// improbable car géré en amont)
508
			// on met le numéro de page à la page courante -1 (car la page
509
			// courante est comptée à partir
510
			// de zéro)
511
			if (pageCourante >= pageTotale && pageCourante != 0) {
512
				pageCourante = pageTotale - 1;
513
				// le cas échéant on en notifie le médiateur
514
				listePaginable.changerNumeroPage(pageCourante);
515
			}
516
		}
517
 
518
		// enfin on rafraichit les informations affichées à partir des nouvelles
519
		// variables de classes mises à jour
520
		rafraichirNumeroPage();
521
 
522
		layout();
523
	}
524
 
525
}