Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
12 david 1
package org.tela_botanica.client.vues;
2
 
3
import org.tela_botanica.client.interfaces.Rafraichissable;
4
import org.tela_botanica.client.observation.ObservationMediateur;
5
 
6
import com.gwtext.client.core.EventCallback;
7
import com.gwtext.client.core.EventObject;
8
import com.gwtext.client.core.Template;
9
import com.gwtext.client.data.Record;
10
import com.gwtext.client.data.SimpleStore;
11
import com.gwtext.client.data.Store;
12
import com.gwtext.client.widgets.Button;
13
import com.gwtext.client.widgets.Toolbar;
14
import com.gwtext.client.widgets.ToolbarButton;
15
import com.gwtext.client.widgets.ToolbarTextItem;
16
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
17
import com.gwtext.client.widgets.form.ComboBox;
18
import com.gwtext.client.widgets.form.Field;
19
import com.gwtext.client.widgets.form.TextField;
20
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
21
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
22
 
23
 
24
/**
25
 * Barre de pagination asynchrone avec filtrage des touches et accès directs et séquentiels à une page
26
 * @author aurelien
27
 *
28
 */
29
public class BarrePaginationObservationVue extends Toolbar implements Rafraichissable {
30
 
31
	/**
32
	 * Le médiateur associé à la vue
33
	 */
34
	private ObservationMediateur	observationMediateur		= null;
35
 
36
	/**
37
	 * Bouton précédent
38
	 */
39
	private ToolbarButton prevPage = new ToolbarButton("<<") ;
40
	/**
41
	 * Bouton suivant
42
	 */
43
	private ToolbarButton suivPage = new ToolbarButton(">>") ;
44
	/**
45
	 * Numéro de la page courante (attention, commence à zéro pour des raisons pratiques)
46
	 */
47
	private int pageCourante = 0 ;
48
	/**
49
	 * Nombre de page total
50
	 */
51
	private int pageTotale = 1 ;
52
	/**
53
	 * Nombre d'élements total
54
	 */
55
	private int nbElement = 0 ;
56
	/**
57
	 * Nombre d'élément par page
58
	 */
59
	private int taillePage = 0 ;
60
	/**
61
	 * Texte statique de la toolbar 1
62
	 */
63
	private ToolbarTextItem page = new ToolbarTextItem("Page ") ;
64
	/**
65
	 * Affichage de la page courante
66
	 */
67
	private TextField champPage = new TextField(""+(pageCourante+1)) ;
68
	/**
69
	 * Affichage de "sur pageTotale "
70
	 */
71
	private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "+pageTotale) ;
72
	/**
73
	 * Texte statique de la toolbar 2
74
	 */
75
	private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ") ;
76
	/**
77
	 * Combobox permettant de selectionner le nombre d'élements à afficher par page
78
	 * et donc de changer la variable taillePage
79
	 */
80
	private ComboBox selecteurTaillePage = new ComboBox() ;
81
	/**
82
	 * Texte statique de la toolbar 3
83
	 */
84
	private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ;
85
	/**
86
	 * Affiche l'intervalle des éléments contenus dans la page
87
	 */
88
	private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ;
89
 
90
	/**
91
	 * retourne le mediateur associe à la barre
92
	 */
93
	public ObservationMediateur getImediateur()
94
	{
95
		return observationMediateur;
96
	}
97
 
98
	/***
99
	 * constructeur sans argument (privé car ne doit pas être utilisé)
100
	 */
101
	private  BarrePaginationObservationVue()
102
	{
103
		super() ;
104
	}
105
 
106
	/**
107
	 * constructeur avec paramètres
108
	 * @param im le médiateur à associer à la barre
109
	 */
110
	public BarrePaginationObservationVue(ObservationMediateur im)
111
	{
112
		super() ;
113
 
114
		observationMediateur = im ;
115
 
116
		// on dispose un peu de texte et quelques espaces pour séparer les éléments
117
		addButton(prevPage) ;
118
		addSpacer() ;
119
		addItem(page) ;
120
		addField(champPage) ;
121
		addItem(surTotalPage) ;
122
		addSpacer() ;
123
		addButton(suivPage) ;
124
 
125
		champPage.setWidth(30) ;
126
 
127
		addSpacer() ;
128
		addItem(afficherNbElem) ;
129
 
130
		// le store contient les valeur possibles pour les tailles de page
131
		final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());
132
		store.load();
133
 
134
		// le template definit ce que l'on affiche pour chaque element du store dans la combobox
135
		final Template tp = new Template("<div class=\"x-combo-list-item\">"
136
				+ "{nb_page}"
137
				+ "<div class=\"x-clear\"></div></div>");
138
		tp.compile();
139
 
140
		selecteurTaillePage.setTpl(tp) ;
141
		selecteurTaillePage.setStore(store) ;
142
		selecteurTaillePage.setWidth(40) ;
143
		selecteurTaillePage.setEditable(false) ;
144
		addField(selecteurTaillePage) ;
145
		selecteurTaillePage.setValue("20") ;
146
		selecteurTaillePage.setWidth(50) ;
147
		addItem(nbElemParPage) ;
148
 
149
		// on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
150
		addFill() ;
151
		addItem(intervalleElements) ;
152
		addSpacer() ;
153
 
154
		// on ajoute les différents listeners
155
		ajouterListeners() ;
156
	}
157
 
158
	/**
159
	 * ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination
160
	 */
161
	private void ajouterListeners()
162
	{
163
		// boutons suivants et précédents
164
		prevPage.addListener(new ButtonListenerAdapter() {
165
 
166
 
167
			public void onClick(Button button, EventObject e) {
168
 
169
				// si la page courante n'est pas la première
170
				if(pageCourante > 0)
171
				{
172
					// on décrémente la page courante de 1
173
					pageCourante -- ;
174
					// on rafraichit l'affichage
175
					rafraichirNumeroPage() ;
176
					// et on notifie le médiateur de l'évenement
177
					observationMediateur.changerNumeroPage(pageCourante) ;
178
 
179
				}
180
			}
181
		}) ;
182
 
183
		suivPage.addListener(new ButtonListenerAdapter() {
184
 
185
 
186
			public void onClick(Button button, EventObject e) {
187
 
188
				// si la page courante n'est pas la dernière
189
				if(pageCourante  < pageTotale -1)
190
				{
191
					// on incrémente la page courante de 1
192
					pageCourante ++ ;
193
					// on rafraichit l'affichage
194
					rafraichirNumeroPage() ;
195
					// et on notifie le médiateur de l'évenement
196
					observationMediateur.changerNumeroPage(pageCourante) ;
197
 
198
				}
199
			}
200
		}) ;
201
 
202
		champPage.addListener(new TextFieldListenerAdapter() {
203
 
204
 
205
			public void onSpecialKey(Field field, EventObject e) {
206
 
207
				// on teste si la touche entrée a été pressée
208
				if(e.getKey() == EventObject.ENTER)
209
				{
210
					int nouvellePage = pageCourante ;
211
					// on teste avec parseInt si la valeur entrée est un entier
212
					 try
213
					 {
214
						nouvellePage = Integer.parseInt(champPage.getRawValue()) ;
215
					 }
216
					 // si ce n'est pas le cas alors on remet le numéro de page correct
217
					 catch(NumberFormatException nfe)
218
					 {
219
						 rafraichirNumeroPage() ;
220
						 champPage.focus(true) ;
221
						 return ;
222
					 }
223
 
224
					// si la conversion reussit on verifie s'il est nécessaire de changer de page
225
					// et si la nouvelle est comprise dans l'intervalle des pages existantes (0..pageTotale)
226
					if(nouvellePage != pageCourante + 1 && nouvellePage > 0 && nouvellePage <= pageTotale)
227
					{
228
							// le cas échéant, on charge la nouvelle page et on notifie le médiateur
229
							changerPageCourante(nouvellePage - 1) ;
230
							observationMediateur.changerNumeroPage(pageCourante);
231
 
232
					}
233
					else
234
					{
235
						// sinon on reaffiche l'ancien numero de page sans rien changer
236
						rafraichirNumeroPage() ;
237
						champPage.focus(true) ;
238
					}
239
				}
240
			}
241
 
242
 
243
			public void onFocus(Field field) {
244
 
245
				champPage.focus(true) ;
246
			}
247
 
248
		});
249
 
250
		// pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
251
		champPage.addKeyPressListener(new EventCallback() {
252
 
253
			public void execute(EventObject e) {
254
 
255
				// si c'est un numerique
256
				if(Character.isDigit((char)e.getCharCode()))
257
				{
258
					// on laisse passer
259
					return ;
260
				}
261
 
262
				// si c'est la touche entrée ou backspace (valider ou effacer)
263
				if(e.getKey() == EventObject.ENTER || e.getKey() == EventObject.BACKSPACE)
264
				{
265
					// on laisse passer
266
					return ;
267
				}
268
				else
269
				{
270
					// sinon on remet le numero de page correct et on annule l'évenement
271
					rafraichirNumeroPage() ;
272
					e.stopEvent() ;
273
				}
274
			}
275
 
276
		}) ;
277
 
278
		// listener pour la selection dans la combobox
279
		selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
280
 
281
 
282
			public void onSelect(ComboBox comboBox, Record record, int index) {
283
 
284
				String nouvelleTaillePageString = comboBox.getStore().getRecordAt(index).getAsString("nb_page") ;
285
				int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString) ;
286
 
287
				// si la taille de page est différente de l'ancienne
288
				if(nouvelleTaillePage != taillePage)
289
				{
290
					// on la change
291
					changerTaillePage(nouvelleTaillePage) ;
292
				}
293
				// et on met la valeur à jour dans la combobox
294
				comboBox.setValue(nouvelleTaillePageString) ;
295
			}
296
 
297
		}) ;
298
	}
299
 
300
	/**
301
	 * Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments
302
	 * à partir des variables de classes
303
	 */
304
	public void rafraichirNumeroPage()
305
	{
306
		surTotalPage.setText(" sur "+pageTotale) ;
307
 
308
		if(nbElement == 0)
309
		{
310
			champPage.setValue(""+(0)) ;
311
			// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
312
			intervalleElements.setText("Observations 0 - 0 sur 0") ;
313
		}
314
		else
315
		{
316
			champPage.setValue(""+(pageCourante+1)) ;
317
 
318
			// si la page n'est pas la dernière
319
			if(pageCourante + 1 != pageTotale)
320
			{
321
				// sauf pour la dernière page qui contient souvent moins d'élements que le nombre d'élements par page
322
				intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+(pageCourante+1)*taillePage+" sur "+nbElement) ;
323
			}
324
			else
325
			{
326
				// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
327
				intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+nbElement+" sur "+nbElement) ;
328
			}
329
		}
330
	}
331
 
332
	/**
333
	 * Met à jour la page en cours
334
	 * @param nouvellePageCourante la nouvelle page en cours
335
	 */
336
	public void changerPageCourante(int nouvellePageCourante)
337
	{
338
		pageCourante = nouvellePageCourante ;
339
	}
340
 
341
	/**
342
	 * Methode héritée de l'interface rafraichissable
343
	 */
344
	public void rafraichir(Object nouvelleDonnees,
345
			boolean repandreRaffraichissement) {
346
 
347
		// si on reçoit un tableau de int
348
		if(nouvelleDonnees instanceof int[])
349
		{
350
			int [] page = (int[])nouvelleDonnees ;
351
			// le premier élement est le nombre de pages totales
352
			pageTotale = page[0] ;
353
			// le second la page en cours
354
			pageCourante = page[1] ;
355
			// le troisième la taille de la page
356
			taillePage = page[2] ;
357
			// et le dernier le nombre total d'éléments
358
			nbElement = page[3] ;
359
 
360
			// si la page courante dépasse la page totale (cas normalement improbable car géré en amont)
361
			// on met le numéro de page à la page courante -1 (car la page courante est comptée à partir
362
			// de zéro)
363
			if(pageCourante >= pageTotale && pageCourante != 0)
364
			{
365
				pageCourante = pageTotale - 1 ;
366
				// le cas échéant on en notifie le médiateur
367
				observationMediateur.changerNumeroPage(pageCourante) ;
368
			}
369
		}
370
 
371
		// enfin on rafraichit les informations affichées à partir des nouvelles variables de classes mises à jour
372
		rafraichirNumeroPage() ;
373
	}
374
 
375
	/**
376
	 * Renvoie les différents intervalles de pages possibles
377
	 * @return un tableau de tableau de string qui contient les différentes taille de pages
378
	 */
379
	public String[][] getNbPages()
380
	{
381
		String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ;
382
 
383
		return pages ;
384
	}
385
 
386
	/**
387
	 * Envoie au médiateur une demande pour modifier la taille de la page
388
	 * (qui va à son tour faire les modifications nécessaires)
389
	 * @param nouvelleTaillePage la nouvelle taille de page (élement appartenant au tableau renvoyé par getNbPages())
390
	 */
391
	public void changerTaillePage(int nouvelleTaillePage) {
392
 
393
		observationMediateur.changerTaillePage(nouvelleTaillePage) ;
394
 
395
	}
396
 
397
 
398
 
399
	/**
400
	 * Selectionne la valeur correspond à celle passée en paramètre dans la combobox (si elle existe)
401
	 * @param nouvelleTaillePage la nouvelle taille de page
402
	 */
403
	public void selectionnerTaillePage(int nouvelleTaillePage) {
404
 
405
		selecteurTaillePage.setValue(""+nouvelleTaillePage) ;
406
	}
407
 
408
}