Subversion Repositories eFlore/Applications.cel

Rev

Details | Last modification | View Log | RSS feed

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