Subversion Repositories eFlore/Applications.coel

Rev

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