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