Subversion Repositories eFlore/Applications.cel

Rev

Rev 2266 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
403 aurelien 1
package org.tela_botanica.client.vues;
2
 
3
import org.tela_botanica.client.interfaces.ListePaginable;
4
import org.tela_botanica.client.interfaces.Rafraichissable;
5
 
6
import com.google.gwt.user.client.Window;
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.event.ComboBoxListenerAdapter;
19
 
20
public class MiniBarrePaginationVue extends Toolbar implements Rafraichissable {
21
 
22
	/**
23
	 * Instance du médiateur à qui on notifie les évnènements
24
	 */
25
	private ListePaginable listePaginable = null;
26
 
27
	/**
28
	 * Bouton précédent
29
	 */
30
	private ToolbarButton prevPage = new ToolbarButton();
31
	/**
32
	 * Bouton suivant
33
	 */
34
	private ToolbarButton suivPage = new ToolbarButton();
35
	/**
36
	 * Numéro de la page courante (attention, commence à zéro pour des raisons
37
	 * pratiques)
38
	 */
39
	private int pageCourante = 0;
40
	/**
41
	 * Nombre de page total
42
	 */
43
	private int pageTotale = 1;
44
	/**
45
	 * Nombre d'élements total
46
	 */
47
	private int nbElement = 0;
48
	/**
49
	 * Nombre d'élément par page
50
	 */
51
	private int taillePage = 0;
52
	/**
53
	 * Texte statique de la toolbar 2
54
	 */
55
	private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ");
56
	/**
57
	 * Combobox permettant de selectionner le nombre d'élements à afficher par
58
	 * page et donc de changer la variable taillePage
59
	 */
60
	private ComboBox selecteurTaillePage = new ComboBox();
61
 
62
	/**
63
	 * Les différents intervalles de page possibles (intialisé par défaut)
64
	 */
65
	String[] pages = { "200","100","50", "20", "10" };
66
 
67
	Store storeIntervalle = null ;
68
 
69
 
70
 
71
	/**
72
	 * Label indiquant le type d'element affiché
73
	 *
74
	 */
75
 
76
	private String labelElement="Elements";
77
 
78
	/**
79
	 * taille de la page par defaut
80
	 *
81
	 */
82
 
83
	private int taillePageDefaut = 50;
84
 
85
 
86
	/**
87
	 * Texte statique de la toolbar 3
88
	 */
89
	private ToolbarTextItem nbElemParPage = new ToolbarTextItem(
90
			labelElement + " par page ");
91
 
92
	/**
93
	 * retourne la liste associé à la barre
94
	 */
95
 
96
	public ListePaginable getlistePaginable() {
97
		return listePaginable;
98
	}
99
 
100
	/***************************************************************************
101
	 * constructeur sans argument (privé car ne doit pas être utilisé)
102
	 */
103
	@SuppressWarnings("unused")
104
	private MiniBarrePaginationVue() {
105
		super();
106
	}
107
 
108
	/**
109
	 * constructeur avec paramètres
110
	 *
111
	 * @param im
112
	 *            le médiateur à associer à la barre
113
	 */
114
	public MiniBarrePaginationVue(ListePaginable lst) {
115
		super();
116
 
117
		listePaginable = lst;
118
 
119
		// on dispose un peu de texte et quelques espaces pour séparer les
120
		// éléments
121
		addButton(prevPage);
122
		addSpacer();
123
		addButton(suivPage);
124
 
125
		addSpacer();
126
		addItem(afficherNbElem);
127
 
128
		prevPage.setIcon("page_prev.png");
129
		suivPage.setIcon("page_suiv.png");
130
 
131
		setIntervallesPages(pages) ;
132
 
133
		// le template definit ce que l'on affiche pour chaque element du store
134
		// dans la combobox
135
		final Template tp = new Template("<div class=\"x-combo-list-item\">"
136
				+ "{nb_page}" + "<div class=\"x-clear\"></div></div>");
137
		tp.compile();
138
 
139
		selecteurTaillePage.setTpl(tp);
140
		selecteurTaillePage.setStore(storeIntervalle);
141
		selecteurTaillePage.setEditable(false);
142
		addField(selecteurTaillePage);
143
		selecteurTaillePage.setValue(""+taillePageDefaut);
144
		selecteurTaillePage.setWidth(50);
406 aurelien 145
 
403 aurelien 146
		addItem(nbElemParPage);
147
 
148
		// on ajoute les différents listeners
149
		ajouterListeners();
150
	}
151
 
152
 
153
	/**
154
	 *  Texte nommant les elements pagines (Images, Observation, truc, machin etc...).
155
	 * 	@param label
156
	 */
157
 
158
	public void setLabelElement(String label) {
159
		this.labelElement = label;
160
		nbElemParPage.setText(labelElement + " par page ");
161
	}
162
 
163
	public void setTaillePageParDefaut(int taille) {
164
		this.taillePageDefaut = taille;
165
		selecteurTaillePage.setValue(""+taillePageDefaut);
166
	}
167
 
168
	public void setIntervallesPages(String[] intervalle)
169
	{
170
		String[][] intervallesPages = new String[intervalle.length][1] ;
171
 
172
		for(int i = 0 ; i < intervalle.length ; i++)
173
		{
174
			intervallesPages[i][0] = intervalle[i] ;
175
		}
176
 
177
		storeIntervalle = new SimpleStore(new String[] { "nb_page" },
178
				intervallesPages );
179
		storeIntervalle.load();
180
		selecteurTaillePage.setStore(storeIntervalle);
181
	}
182
 
183
 
184
	/**
185
	 * ajoute les différents listeners nécessaires au bon fonctionnement des
186
	 * éléments de la barre de pagination
187
	 */
188
	private void ajouterListeners() {
189
		// boutons suivants et précédents
190
		prevPage.addListener(new ButtonListenerAdapter() {
191
 
1291 aurelien 192
			@Override
403 aurelien 193
			public void onClick(Button button, EventObject e) {
194
 
195
				// si la page courante n'est pas la première
196
				if (pageCourante > 0) {
197
					// on décrémente la page courante de 1
198
					pageCourante--;
199
					// on rafraichit l'affichage
200
					// et on notifie le médiateur de l'évenement
201
					listePaginable.changerNumeroPage(pageCourante);
202
 
203
				}
204
			}
205
		});
206
 
207
		suivPage.addListener(new ButtonListenerAdapter() {
208
 
1291 aurelien 209
			@Override
403 aurelien 210
			public void onClick(Button button, EventObject e) {
406 aurelien 211
 
403 aurelien 212
				// si la page courante n'est pas la dernière
213
				if (pageCourante < pageTotale - 1) {
214
					// on incrémente la page courante de 1
215
					pageCourante++;
216
					// on rafraichit l'affichage
217
					// et on notifie le médiateur de l'évenement
218
					listePaginable.changerNumeroPage(pageCourante);
219
 
220
				}
221
			}
222
		});
223
 
224
		// listener pour la selection dans la combobox
225
		selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
226
 
1291 aurelien 227
			@Override
403 aurelien 228
			public void onSelect(ComboBox comboBox, Record record, int index) {
229
 
230
				String nouvelleTaillePageString = comboBox.getStore()
231
						.getRecordAt(index).getAsString("nb_page");
232
				int nouvelleTaillePage = Integer
233
						.parseInt(nouvelleTaillePageString);
234
 
235
				// si la taille de page est différente de l'ancienne
236
				if (nouvelleTaillePage != taillePage) {
237
					// on la change
238
					changerTaillePage(nouvelleTaillePage);
239
				}
240
				// et on met la valeur à jour dans la combobox
241
				comboBox.setValue(nouvelleTaillePageString);
242
			}
243
 
244
		});
245
	}
246
 
247
	/**
248
	 * Met à jour la page en cours
249
	 *
250
	 * @param nouvellePageCourante
251
	 *            la nouvelle page en cours
252
	 */
253
	public void changerPageCourante(int nouvellePageCourante) {
254
		pageCourante = nouvellePageCourante;
255
	}
256
 
257
	/**
258
	 * Methode héritée de l'interface rafraichissable
259
	 */
1291 aurelien 260
	@Override
403 aurelien 261
	public void rafraichir(Object nouvelleDonnees,
262
			boolean repandreRaffraichissement) {
263
 
264
		// si on reçoit un tableau de int
265
		if (nouvelleDonnees instanceof int[]) {
266
			int[] page = (int[]) nouvelleDonnees;
267
			// le premier élement est le nombre de pages totales
268
			pageTotale = page[0];
269
			// le second la page en cours
270
			pageCourante = page[1];
271
			// le troisième la taille de la page
272
			taillePage = page[2];
273
			// et le dernier le nombre total d'éléments
274
			nbElement = page[3];
275
 
276
			// si la page courante dépasse la page totale (cas normalement
277
			// improbable car géré en amont)
278
			// on met le numéro de page à la page courante -1 (car la page
279
			// courante est comptée à partir
280
			// de zéro)
281
			if (pageCourante >= pageTotale && pageCourante != 0) {
282
				pageCourante = pageTotale - 1;
283
				// le cas échéant on en notifie le médiateur
284
				listePaginable.changerNumeroPage(pageCourante);
285
			}
286
		}
287
	}
288
 
289
	/**
290
	 * Renvoie les différents intervalles de pages possibles
291
	 *
292
	 * @return un tableau de string qui contient les différentes
293
	 *         taille de pages
294
	 */
295
	public String[] getNbPages() {
296
		return pages;
297
	}
298
 
299
	/**
300
	 * Envoie au médiateur une demande pour modifier la taille de la page (qui
301
	 * va à son tour faire les modifications nécessaires)
302
	 *
303
	 * @param nouvelleTaillePage
304
	 *            la nouvelle taille de page (élement appartenant au tableau
305
	 *            renvoyé par getNbPages())
306
	 */
307
	public void changerTaillePage(int nouvelleTaillePage) {
308
		listePaginable.changerTaillePage(nouvelleTaillePage);
309
	}
310
 
311
	/**
312
	 * Selectionne la valeur correspond à celle passée en paramètre dans la
313
	 * combobox (si elle existe)
314
	 *
315
	 * @param nouvelleTaillePage
316
	 *            la nouvelle taille de page
317
	 */
318
	public void selectionnerTaillePage(int nouvelleTaillePage) {
319
		selecteurTaillePage.setValue("" + nouvelleTaillePage);
320
	}
321
}