Subversion Repositories eFlore/Applications.cel

Rev

Rev 2 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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