Subversion Repositories eFlore/Applications.cel

Rev

Rev 128 | Details | Compare with Previous | 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
 
128 aurelien 149
		// on remplit l'espace pour que l'intervalle d'élement se place à droite
150
		// de la barre
151
		addItem(intervalleElements);
152
		addSpacer();
153
		// on remplit l'espace pour que l'intervalle d'élement se place à droite
154
		// de la barre
155
		addFill();
156
 
5 aperonnet 157
		// on dispose un peu de texte et quelques espaces pour séparer les
158
		// éléments
159
		addButton(prevPage);
160
		addSpacer();
161
		addItem(page);
162
		addField(champPage);
163
		addItem(surTotalPage);
164
		addSpacer();
165
		addButton(suivPage);
166
 
167
		champPage.setWidth(30);
168
 
169
		addSpacer();
170
		addItem(afficherNbElem);
171
 
172
		prevPage.setIcon("page_prev.png");
173
		suivPage.setIcon("page_suiv.png");
174
 
60 jpm 175
		setIntervallesPages(pages) ;
5 aperonnet 176
 
177
		// le template definit ce que l'on affiche pour chaque element du store
178
		// dans la combobox
179
		final Template tp = new Template("<div class=\"x-combo-list-item\">"
180
				+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
2 aperonnet 181
		tp.compile();
5 aperonnet 182
 
183
		selecteurTaillePage.setTpl(tp);
60 jpm 184
		selecteurTaillePage.setStore(storeIntervalle);
5 aperonnet 185
		selecteurTaillePage.setWidth(40);
186
		selecteurTaillePage.setEditable(false);
187
		addField(selecteurTaillePage);
59 david 188
		selecteurTaillePage.setValue(""+taillePageDefaut);
5 aperonnet 189
		selecteurTaillePage.setWidth(50);
190
		addItem(nbElemParPage);
59 david 191
 
5 aperonnet 192
 
2 aperonnet 193
		// on ajoute les différents listeners
5 aperonnet 194
		ajouterListeners();
2 aperonnet 195
	}
5 aperonnet 196
 
59 david 197
 
2 aperonnet 198
	/**
59 david 199
	 *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
200
	 * 	@param label
201
	 */
202
 
203
	public void setLabelElement(String label) {
204
		this.labelElement = label;
205
		nbElemParPage.setText(labelElement + " par page ");
206
		intervalleElements.setText(labelElement + " " + pageCourante * taillePage + " sur " + nbElement);
207
	}
208
 
209
	public void setTaillePageParDefaut(int taille) {
210
		this.taillePageDefaut = taille;
211
		selecteurTaillePage.setValue(""+taillePageDefaut);
212
	}
213
 
60 jpm 214
	public void setIntervallesPages(String[] intervalle)
215
	{
216
		String[][] intervallesPages = new String[intervalle.length][1] ;
217
 
218
		for(int i = 0 ; i < intervalle.length ; i++)
219
		{
220
			intervallesPages[i][0] = intervalle[i] ;
221
		}
222
 
223
		storeIntervalle = new SimpleStore(new String[] { "nb_page" },
224
				intervallesPages );
225
		storeIntervalle.load();
226
		selecteurTaillePage.setStore(storeIntervalle);
227
	}
59 david 228
 
60 jpm 229
 
59 david 230
	/**
5 aperonnet 231
	 * ajoute les différents listeners nécessaires au bon fonctionnement des
232
	 * éléments de la barre de pagination
2 aperonnet 233
	 */
5 aperonnet 234
	private void ajouterListeners() {
59 david 235
 
236
 
237
 
5 aperonnet 238
		// boutons suivants et précédents
2 aperonnet 239
		prevPage.addListener(new ButtonListenerAdapter() {
240
 
241
			public void onClick(Button button, EventObject e) {
5 aperonnet 242
 
2 aperonnet 243
				// si la page courante n'est pas la première
5 aperonnet 244
				if (pageCourante > 0) {
2 aperonnet 245
					// on décrémente la page courante de 1
5 aperonnet 246
					pageCourante--;
2 aperonnet 247
					// on rafraichit l'affichage
5 aperonnet 248
					rafraichirNumeroPage();
2 aperonnet 249
					// et on notifie le médiateur de l'évenement
56 david 250
					listePaginable.changerNumeroPage(pageCourante);
5 aperonnet 251
 
2 aperonnet 252
				}
253
			}
5 aperonnet 254
		});
255
 
2 aperonnet 256
		suivPage.addListener(new ButtonListenerAdapter() {
5 aperonnet 257
 
2 aperonnet 258
			public void onClick(Button button, EventObject e) {
5 aperonnet 259
 
2 aperonnet 260
				// si la page courante n'est pas la dernière
5 aperonnet 261
				if (pageCourante < pageTotale - 1) {
2 aperonnet 262
					// on incrémente la page courante de 1
5 aperonnet 263
					pageCourante++;
2 aperonnet 264
					// on rafraichit l'affichage
5 aperonnet 265
					rafraichirNumeroPage();
2 aperonnet 266
					// et on notifie le médiateur de l'évenement
56 david 267
					listePaginable.changerNumeroPage(pageCourante);
5 aperonnet 268
 
269
				}
2 aperonnet 270
			}
5 aperonnet 271
		});
272
 
2 aperonnet 273
		champPage.addListener(new TextFieldListenerAdapter() {
274
 
275
			public void onSpecialKey(Field field, EventObject e) {
5 aperonnet 276
 
2 aperonnet 277
				// on teste si la touche entrée a été pressée
5 aperonnet 278
				if (e.getKey() == EventObject.ENTER) {
279
					int nouvellePage = pageCourante;
2 aperonnet 280
					// on teste avec parseInt si la valeur entrée est un entier
5 aperonnet 281
					try {
282
						nouvellePage = Integer
283
								.parseInt(champPage.getRawValue());
284
					}
285
					// si ce n'est pas le cas alors on remet le numéro de page
286
					// correct
287
					catch (NumberFormatException nfe) {
288
						rafraichirNumeroPage();
289
						champPage.focus(true);
290
						return;
291
					}
2 aperonnet 292
 
5 aperonnet 293
					// si la conversion reussit on verifie s'il est nécessaire
294
					// de changer de page
295
					// et si la nouvelle est comprise dans l'intervalle des
296
					// pages existantes (0..pageTotale)
297
					if (nouvellePage != pageCourante + 1 && nouvellePage > 0
298
							&& nouvellePage <= pageTotale) {
299
						// le cas échéant, on charge la nouvelle page et on
300
						// notifie le médiateur
301
						changerPageCourante(nouvellePage - 1);
56 david 302
						listePaginable.changerNumeroPage(pageCourante);
5 aperonnet 303
 
304
					} else {
305
						// sinon on reaffiche l'ancien numero de page sans rien
306
						// changer
307
						rafraichirNumeroPage();
308
						champPage.focus(true);
2 aperonnet 309
					}
310
				}
311
			}
5 aperonnet 312
 
2 aperonnet 313
			public void onFocus(Field field) {
5 aperonnet 314
 
315
				champPage.focus(true);
2 aperonnet 316
			}
5 aperonnet 317
 
2 aperonnet 318
		});
5 aperonnet 319
 
320
		// pour éviter de se compliquer la vie, on filtre tous les charactères
321
		// non numériques
2 aperonnet 322
		champPage.addKeyPressListener(new EventCallback() {
323
 
324
			public void execute(EventObject e) {
5 aperonnet 325
 
2 aperonnet 326
				// si c'est un numerique
5 aperonnet 327
				if (Character.isDigit((char) e.getCharCode())) {
2 aperonnet 328
					// on laisse passer
5 aperonnet 329
					return;
2 aperonnet 330
				}
5 aperonnet 331
 
2 aperonnet 332
				// si c'est la touche entrée ou backspace (valider ou effacer)
5 aperonnet 333
				if (e.getKey() == EventObject.ENTER
334
						|| e.getKey() == EventObject.BACKSPACE) {
2 aperonnet 335
					// on laisse passer
5 aperonnet 336
					return;
337
				} else {
338
					// sinon on remet le numero de page correct et on annule
339
					// l'évenement
340
					rafraichirNumeroPage();
341
					e.stopEvent();
2 aperonnet 342
				}
343
			}
5 aperonnet 344
 
345
		});
346
 
347
		// listener pour la selection dans la combobox
2 aperonnet 348
		selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
5 aperonnet 349
 
2 aperonnet 350
			public void onSelect(ComboBox comboBox, Record record, int index) {
5 aperonnet 351
 
352
				String nouvelleTaillePageString = comboBox.getStore()
353
						.getRecordAt(index).getAsString("nb_page");
354
				int nouvelleTaillePage = Integer
355
						.parseInt(nouvelleTaillePageString);
356
 
2 aperonnet 357
				// si la taille de page est différente de l'ancienne
5 aperonnet 358
				if (nouvelleTaillePage != taillePage) {
2 aperonnet 359
					// on la change
5 aperonnet 360
					changerTaillePage(nouvelleTaillePage);
2 aperonnet 361
				}
362
				// et on met la valeur à jour dans la combobox
5 aperonnet 363
				comboBox.setValue(nouvelleTaillePageString);
2 aperonnet 364
			}
5 aperonnet 365
 
366
		});
2 aperonnet 367
	}
5 aperonnet 368
 
2 aperonnet 369
	/**
5 aperonnet 370
	 * Met à jour les affichage sur les numéros de pages et d'intervalle
371
	 * d'éléments à partir des variables de classes
2 aperonnet 372
	 */
5 aperonnet 373
	public void rafraichirNumeroPage() {
374
		surTotalPage.setText(" sur " + pageTotale);
375
 
376
		if (nbElement == 0) {
377
			champPage.setValue("" + (0));
378
			// on met simplement à jour l'intervalle qui contient toujours le
379
			// même nombre d'éléments
59 david 380
			intervalleElements.setText(labelElement + " 0 - 0 sur 0");
5 aperonnet 381
		} else {
382
			champPage.setValue("" + (pageCourante + 1));
383
 
384
			// si la page n'est pas la dernière
385
			if (pageCourante + 1 != pageTotale) {
386
				// sauf pour la dernière page qui contient souvent moins
387
				// d'élements que le nombre d'élements par page
59 david 388
				intervalleElements.setText(labelElement + " " + pageCourante
5 aperonnet 389
						* taillePage + " - " + (pageCourante + 1) * taillePage
390
						+ " sur " + nbElement);
391
			} else {
392
				// on met simplement à jour l'intervalle qui contient toujours
393
				// le même nombre d'éléments
59 david 394
				intervalleElements.setText(labelElement + " " + pageCourante
5 aperonnet 395
						* taillePage + " - " + nbElement + " sur " + nbElement);
396
			}
2 aperonnet 397
		}
398
	}
5 aperonnet 399
 
2 aperonnet 400
	/**
5 aperonnet 401
	 * Met à jour la page en cours
402
	 *
403
	 * @param nouvellePageCourante
404
	 *            la nouvelle page en cours
2 aperonnet 405
	 */
5 aperonnet 406
	public void changerPageCourante(int nouvellePageCourante) {
407
		pageCourante = nouvellePageCourante;
2 aperonnet 408
	}
5 aperonnet 409
 
2 aperonnet 410
	/**
411
	 * Methode héritée de l'interface rafraichissable
412
	 */
413
	public void rafraichir(Object nouvelleDonnees,
414
			boolean repandreRaffraichissement) {
5 aperonnet 415
 
2 aperonnet 416
		// si on reçoit un tableau de int
5 aperonnet 417
		if (nouvelleDonnees instanceof int[]) {
418
			int[] page = (int[]) nouvelleDonnees;
419
			// le premier élement est le nombre de pages totales
420
			pageTotale = page[0];
2 aperonnet 421
			// le second la page en cours
5 aperonnet 422
			pageCourante = page[1];
2 aperonnet 423
			// le troisième la taille de la page
5 aperonnet 424
			taillePage = page[2];
2 aperonnet 425
			// et le dernier le nombre total d'éléments
5 aperonnet 426
			nbElement = page[3];
427
 
428
			// si la page courante dépasse la page totale (cas normalement
429
			// improbable car géré en amont)
430
			// on met le numéro de page à la page courante -1 (car la page
431
			// courante est comptée à partir
2 aperonnet 432
			// de zéro)
5 aperonnet 433
			if (pageCourante >= pageTotale && pageCourante != 0) {
434
				pageCourante = pageTotale - 1;
2 aperonnet 435
				// le cas échéant on en notifie le médiateur
56 david 436
				listePaginable.changerNumeroPage(pageCourante);
2 aperonnet 437
			}
438
		}
5 aperonnet 439
 
440
		// enfin on rafraichit les informations affichées à partir des nouvelles
441
		// variables de classes mises à jour
442
		rafraichirNumeroPage();
2 aperonnet 443
	}
5 aperonnet 444
 
2 aperonnet 445
	/**
446
	 * Renvoie les différents intervalles de pages possibles
5 aperonnet 447
	 *
60 jpm 448
	 * @return un tableau de string qui contient les différentes
5 aperonnet 449
	 *         taille de pages
2 aperonnet 450
	 */
60 jpm 451
	public String[] getNbPages() {
5 aperonnet 452
 
453
		return pages;
2 aperonnet 454
	}
455
 
456
	/**
5 aperonnet 457
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
458
	 * va à son tour faire les modifications nécessaires)
459
	 *
460
	 * @param nouvelleTaillePage
461
	 *            la nouvelle taille de page (élement appartenant au tableau
462
	 *            renvoyé par getNbPages())
2 aperonnet 463
	 */
464
	public void changerTaillePage(int nouvelleTaillePage) {
5 aperonnet 465
 
56 david 466
		listePaginable.changerTaillePage(nouvelleTaillePage);
5 aperonnet 467
 
2 aperonnet 468
	}
5 aperonnet 469
 
2 aperonnet 470
	/**
5 aperonnet 471
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
472
	 * combobox (si elle existe)
473
	 *
474
	 * @param nouvelleTaillePage
475
	 *            la nouvelle taille de page
2 aperonnet 476
	 */
477
	public void selectionnerTaillePage(int nouvelleTaillePage) {
5 aperonnet 478
 
479
		selecteurTaillePage.setValue("" + nouvelleTaillePage);
2 aperonnet 480
	}
5 aperonnet 481
 
2 aperonnet 482
}