Subversion Repositories eFlore/Archives.cel-v2

Rev

Rev 40 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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