Subversion Repositories eFlore/Applications.cel

Rev

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