Subversion Repositories eFlore/Archives.cel-v2

Rev

Rev 40 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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