Subversion Repositories eFlore/Applications.cel

Rev

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

Rev 20 Rev 31
1 
package org.tela_botanica.client.observation;
 1 
package org.tela_botanica.client.observation;
2 
 
 2 
 
3 
 
 3 
 
4 
import java.util.Iterator;
 4 
import java.util.Iterator;
5 
import org.tela_botanica.client.CarnetEnLigneMediateur;
 5 
import org.tela_botanica.client.CarnetEnLigneMediateur;
6 
import org.tela_botanica.client.interfaces.FournisseurListe;
 6 
import org.tela_botanica.client.interfaces.FournisseurListe;
7 
import org.tela_botanica.client.interfaces.Rafraichissable;
 7 
import org.tela_botanica.client.interfaces.Rafraichissable;
8 
import org.tela_botanica.client.modeles.ListeObservation;
 8 
import org.tela_botanica.client.modeles.ListeObservation;
9 
import org.tela_botanica.client.modeles.Observation;
 9 
import org.tela_botanica.client.modeles.Observation;
10 
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
 10 
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue;
11 
import org.tela_botanica.client.vues.ListeObservationVue;
 11 
import org.tela_botanica.client.vues.ListeObservationVue;
12 
 
 12 
 
13 
import com.gwtext.client.data.ArrayReader;
 13 
import com.gwtext.client.data.ArrayReader;
14 
import com.gwtext.client.data.FieldDef;
 14 
import com.gwtext.client.data.FieldDef;
15 
import com.gwtext.client.data.MemoryProxy;
 15 
import com.gwtext.client.data.MemoryProxy;
16 
import com.gwtext.client.data.RecordDef;
 16 
import com.gwtext.client.data.RecordDef;
17 
import com.gwtext.client.data.Store;
 17 
import com.gwtext.client.data.Store;
18 
import com.gwtext.client.data.StringFieldDef;
 18 
import com.gwtext.client.data.StringFieldDef;
19 
import com.gwtext.client.widgets.Panel;
 19 
import com.gwtext.client.widgets.Panel;
20 
import com.gwtext.client.widgets.TabPanel;
 20 
import com.gwtext.client.widgets.TabPanel;
21 
 
 21 
 
22 
/**
 22 
/**
23 
 * Mediateur gérant les interactions entre vues et les echanges de données
 23 
 * Mediateur gérant les interactions entre vues et les echanges de données
24 
 * C'est un singleton.
24 
 * C'est un singleton.
25 
 * @author aurelien
 25 
 * @author aurelien
26 
 *
 26 
 *
27 
 */
 27 
 */
28 
public class ObservationMediateur implements Rafraichissable {
 28 
public class ObservationMediateur implements Rafraichissable {
29
29
30 
	/**
 30 
	/**
31 
	 * booleen qui verifie l'unicite de l'instance (donc static)
 31 
	 * booleen qui verifie l'unicite de l'instance (donc static)
32 
	 */
 32 
	 */
33 
	private static boolean estInstancie = false ;
33 
	private static boolean estInstancie = false ;
- 
 
 34 
 
- 
 
 35 
	/**
- 
 
 36 
	 * pointeur sur le médiateur (pour le pattern singleton)
- 
 
 37 
	 */
- 
 
 38 
	private static ObservationMediateur thisMediateur = null ;
34
39
35 
	/** Mediateur general de l'application carnet en ligne
 40 
	/** Mediateur general de l'application carnet en ligne
36 
	 *
41 
	 *
37 
	 *
42 
	 *
38 
	 */
 43 
	 */
39
44
40 
	private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
 45 
	private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
41
46
42
47
43 
	/**
 48 
	/**
44 
	 * modele de données
 49 
	 * modele de données
45 
	 */
 50 
	 */
46 
	private ObservationModele observationModele = null ;
 51 
	private ObservationModele observationModele = null ;
47
52
48
53
49 
	/**
 54 
	/**
50 
	 * panneau principal des Observation (onglet "observation")
 55 
	 * panneau principal des Observation (onglet "observation")
51 
	 */
 56 
	 */
52 
	private final Panel panneauPrincipalObservation = new Panel("Observation");
 57 
	private final Panel panneauPrincipalObservation = new Panel("Observation");
53
58
54 
	/**
 59 
	/**
55 
	 * panneau a onglet pour la liste
 60 
	 * panneau a onglet pour la liste
56 
	 */
61 
	 */
57 
	private TabPanel ongletsObservation = null ;
 62 
	private TabPanel ongletsObservation = null ;
58
63
59 
	/**
 64 
	/**
60 
	 * conteneur du panneau a onglets
 65 
	 * conteneur du panneau a onglets
61 
	 */
 66 
	 */
62 
	private Panel panneauMenuEtOngletsObservation = null ;
 67 
	private Panel panneauMenuEtOngletsObservation = null ;
63
68
64 
	/**
 69 
	/**
65 
	 * liste détaillée des Observations
 70 
	 * liste détaillée des Observations
66 
	 */
 71 
	 */
67 
	private ListeObservationVue listeObservation = null ;
 72 
	private ListeObservationVue listeObservation = null ;
68
73
69 
	/**
 74 
	/**
70 
	 * Saisie des Observations
 75 
	 * Saisie des Observations
71 
	 */
 76 
	 */
72
77
73 
	private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
 78 
	private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null;
74 
	/**
 79 
	/**
75 
	 * l'indice du dernier onglet sélectionné
 80 
	 * l'indice du dernier onglet sélectionné
76 
	 */
 81 
	 */
77 
	private int dernierIndexOnglet = 0 ;
82 
	private int dernierIndexOnglet = 0 ;
78
83
79 
	/**
 84 
	/**
80 
	 * booleen explicitant s'il y a une selection en cours
 85 
	 * booleen explicitant s'il y a une selection en cours
81 
	 */
 86 
	 */
82 
	private boolean selection = false ;
 87 
	private boolean selection = false ;
83
- 
 
84
- 
 
85 
 
 88
86 
	/**
 - 
 
87 
	 *
89 
	/**
88 
	 * Numéro de page en cours
 90 
	 * Numéro de page en cours
89 
	 */
 91 
	 */
90 
	private int pageEncours = 0 ;
 92 
	private int pageEncours = 0 ;
91 
	/**
 93 
	/**
92 
	 * Nombre de pages totales
 94 
	 * Nombre de pages totales
93 
	 */
 95 
	 */
94 
	private int pageMax = 1 ;
 96 
	private int pageMax = 1 ;
95 
	/**
 97 
	/**
96 
	 * Taille de page (par défaut 20)
 98 
	 * Taille de page (par défaut 20)
97 
	 */
 99 
	 */
98 
	private int taillePage = 20 ;
 100 
	private int taillePage = 20 ;
99 
	/**
 101 
	/**
100 
	 * Nombre d'éléments total correspondant à la requete
 102 
	 * Nombre d'éléments total correspondant à la requete
101 
	 */
 103 
	 */
102 
	private int nbElements = 0 ;
 104 
	private int nbElements = 0 ;
103
105
104
106
105 
	/**
 107 
	/**
106 
	 * Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
 108 
	 * Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande
107 
	 */
 109 
	 */
108 
	private Store st = null ;
 110 
	private Store st = null ;
109
111
110
112
111
113
112
114
113 
	/**
 115 
	/**
114 
	 * La liste des observations affichées en cours (verifier utilité)
 116 
	 * La liste des observations affichées en cours (verifier utilité)
115 
	 */
 117 
	 */
116
118
117 
	private ListeObservation cacheObservation = new ListeObservation(0) ;
 119 
	private ListeObservation cacheObservation = new ListeObservation(0) ;
118 
	/**
 120 
	/**
119
121
120
122
121
123
122 
	/**
 124 
	/**
123 
	 * constructeur privé (on accède a la classe par la méthode getInstance
 125 
	 * constructeur privé (on accède a la classe par la méthode getInstance
124 
	 */
 126 
	 */
125
127
126
128
127 
	private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
 129 
	private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur )
128 
	{
 130 
	{
129 
		this.carnetEnLigneMediateur=carnetEnLigneMediateur;
 131 
		this.carnetEnLigneMediateur=carnetEnLigneMediateur;
130
132
131
133
132
134
133 
		// Demande d'identification
 135 
		// Demande d'identification
134 
//		afficherMenuId() ;
 136 
//		afficherMenuId() ;
135 
 
 137 
 
136
138
137 
		// on crée un modèle
 139 
		// on crée un modèle
138 
		observationModele = ObservationModele.Instance(this);
 140 
		observationModele = ObservationModele.Instance(this);
139
141
140
142
141 
		// on gère la mise en page du panneau principal
 143 
		// on gère la mise en page du panneau principal
142 
		//panneauPrincipalObservation.setLayout(new BorderLayout());
 144 
		//panneauPrincipalObservation.setLayout(new BorderLayout());
143
145
144 
		// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
 146 
		// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur
145 
	//	panneauMenuEtOngletsObservation = new Panel("gg") ;
 147 
	//	panneauMenuEtOngletsObservation = new Panel("gg") ;
146 
	//	panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
 148 
	//	panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ;
147
149
148 
		// le panneau à onglet qui contient la vue
 150 
		// le panneau à onglet qui contient la vue
149 
		//ongletsObservation = new TabPanel();
 151 
		//ongletsObservation = new TabPanel();
150
152
151
153
152 
		// la liste des observations
 154 
		// la liste des observations
153
155
154 
		//Panel panneauListeObservation = new Panel("Liste");
 156 
		//Panel panneauListeObservation = new Panel("Liste");
155
157
156 
		listeObservation = new ListeObservationVue(this);
 158 
		listeObservation = new ListeObservationVue(this);
157
159
158
160
159 
		// Le formulaire de saisie / modification d'observation
 161 
		// Le formulaire de saisie / modification d'observation
160
162
161 
		formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
 163 
		formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this);
162 
 
 164 
 
163
165
164 
		//panneauListeObservation.setLayout(new FitLayout());
 166 
		//panneauListeObservation.setLayout(new FitLayout());
165 
		//panneauListeObservation.setSize(600,600);
 167 
		//panneauListeObservation.setSize(600,600);
166 
		//panneauListeObservation.add(listeObservation);
 168 
		//panneauListeObservation.add(listeObservation);
167
169
168
170
169 
		// on ajoute les panneaux au panneau à onglets
 171 
		// on ajoute les panneaux au panneau à onglets
170 
		//ongletsObservation.add(panneauListeObservation);
 172 
		//ongletsObservation.add(panneauListeObservation);
171
173
172
174
173 
		// les onglets au centre
 175 
		// les onglets au centre
174 
//		panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
 176 
//		panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre);
175
177
176 
		// on ajoute le panneau qui contient le menu et les onglets d'images au centre
 178 
		// on ajoute le panneau qui contient le menu et les onglets d'images au centre
177 
		//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
 179 
		//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre);
178
180
179 
		panneauPrincipalObservation.add(formulaireSaisieObservationVue);
 181 
		panneauPrincipalObservation.add(formulaireSaisieObservationVue);
180
182
181 
		panneauPrincipalObservation.add(listeObservation);
 183 
		panneauPrincipalObservation.add(listeObservation);
182
184
183
185
184
186
185 
 
 187 
 
186 
	}
 188 
	}
187 
 
 189 
 
188 
 
 190 
 
189 
	/**
 191 
	/**
190 
	 * Retourne une instance de manière unique
 192 
	 * Retourne une instance de manière unique
191 
	 * @return l'instance unique du médiateur
 193 
	 * @return l'instance unique du médiateur
192 
	 */
 194 
	 */
193 
	public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
 195 
	public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur)
194 
	{
 196 
	{
195 
			if(!estInstancie)
 197 
			if(!estInstancie || thisMediateur == null)
196 
			{
 198 
			{
197 
				estInstancie = true ;
 199 
				estInstancie = true ;
198 
				return new ObservationMediateur(carnetEnLigneMediateur) ;
 200 
				thisMediateur = new ObservationMediateur(carnetEnLigneMediateur) ;
199 
			}
 - 
 
200 
			else
 - 
 
201 
			{
 - 
 
202 
				return null ;
 - 
 
203
- 
 
204 
			}
 201 
			}
- 
 
 202
- 
 
 203 
			return thisMediateur ;
205 
	}
 204 
	}
206
205
207
206
208
207
209 
	/**
 208 
	/**
210 
	 * envoie au modèle une demande de mise a jour
 209 
	 * envoie au modèle une demande de mise a jour
211 
	 */
 210 
	 */
212 
 
 211 
 
213 
 
 212 
 
214 
	public void obtenirNombreObservation() {
 213 
	public void obtenirNombreObservation() {
215
214
216
215
217 
			listeObservation.masquerChargement();
 216 
			listeObservation.masquerChargement();
218 
		    observationModele.obtenirNombreObservation(this) ;
 217 
		    observationModele.obtenirNombreObservation(this) ;
219
218
220 
	}
 219 
	}
221
220
222 
	/**
 221 
	/**
223 
	 * envoie au modèle une demande de mise a jour
 222 
	 * envoie au modèle une demande de mise a jour
224 
	 */
 223 
	 */
225 
 
 224 
 
226 
 
 225 
 
227 
	public void obtenirListeObservation() {
 226 
	public void obtenirListeObservation() {
228
227
229 
 
 228 
 
230 
			observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
 229 
			observationModele.obtenirListeObservation(this, taillePage, pageEncours) ;
231
230
232 
	}
 - 
 
233 
 
 - 
 
234 
 
 - 
 
235
- 
 
236
231 
	}
237
232
238 
	/**
 233 
	/**
239 
	 * C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
 234 
	 * C'est dans cette fonction que doivent être renvoyé les valeurs des filtres
240 
	 * sous forme de tableau [nom, valeur]
 235 
	 * sous forme de tableau [nom, valeur]
241 
	 * @return Les noms et valeurs des filtres
 236 
	 * @return Les noms et valeurs des filtres
242 
	 */
 237 
	 */
243 
	public String[][] renvoyerFiltres()
 238 
	public String[][] renvoyerFiltres()
244 
	{
 239 
	{
245 
		String[][] valeursFiltres = { {"location","Saint-Martin-de-Londres"} } ;
 240 
		String[][] valeursFiltres = { {"location","Saint-Martin-de-Londres"} } ;
246
241
247
242
248 
		return valeursFiltres ;
 243 
		return valeursFiltres ;
249 
	}
 244 
	}
250 
 
 245 
 
251 
 
 246 
 
252 
	public String getIdentifiant() {
 247 
	public String getIdentifiant() {
253
248
254 
		return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
 249 
		return carnetEnLigneMediateur.getUtilisateur().getIdentifiant();
255
250
256 
	}
 251 
	}
257 
 
 252 
 
258 
 
 253 
 
259 
	public Panel getPanneauPrincipalObservation() {
 254 
	public Panel getPanneauPrincipalObservation() {
260 
		return panneauPrincipalObservation;
 255 
		return panneauPrincipalObservation;
261 
	}
 256 
	}
262
257
263
258
264
259
265 
	// FIXME TODO : plutot dans la listevu non ?
 260 
	// FIXME TODO : plutot dans la listevu non ?
266 
 
 261 
 
267 
	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
 262 
	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {
268
263
269
264
270
265
271 
//		 si l'on a reçu une liste d'observation
 266 
//		 si l'on a reçu une liste d'observation
272 
		if(nouvelleDonnees instanceof ListeObservation)
 267 
		if(nouvelleDonnees instanceof ListeObservation)
273 
		{
 268 
		{
274
269
275 
				ListeObservation data = (ListeObservation) nouvelleDonnees ;
 270 
				ListeObservation data = (ListeObservation) nouvelleDonnees ;
276 
				Object[][] observationData = new Object[data.size()][8];
 271 
				Object[][] observationData = new Object[data.size()][8];
277 
				int i = 0 ;
 272 
				int i = 0 ;
278
273
279 
				if(data.size() == 0)
 274 
				if(data.size() == 0)
280 
				{
 275 
				{
281 
					pageEncours = 0 ;
 276 
					pageEncours = 0 ;
282 
				}
 277 
				}
283
278
284 
				// on la parse et on récupère les informations quiç nous interessent
 279 
				// on la parse et on récupère les informations quiç nous interessent
285 
				for (Iterator it = data.keySet().iterator(); it.hasNext();)
280 
				for (Iterator it = data.keySet().iterator(); it.hasNext();)
286 
				{
 281 
				{
287
282
288 
					Observation obs=(Observation) data.get(it.next());
 283 
					Observation obs=(Observation) data.get(it.next());
289
284
290 
					observationData[i][0]= obs.getTransmis();
 285 
					observationData[i][0]= obs.getTransmis();
291 
					observationData[i][1]= obs.getNomSaisi();
 286 
					observationData[i][1]= obs.getNomSaisi();
292 
					observationData[i][2]= obs.getNomRetenu();
 287 
					observationData[i][2]= obs.getNomRetenu();
293 
					observationData[i][3]= obs.getLieudit();
 288 
					observationData[i][3]= obs.getLieudit();
294 
					observationData[i][4]= obs.getDate();
 289 
					observationData[i][4]= obs.getDate();
295 
					observationData[i][5]= obs.getNumeroOrdre();
 290 
					observationData[i][5]= obs.getNumeroOrdre();
296
- 
 
297
- 
 
298 
 
 - 
 
299
- 
 
300
291
301 
					i++ ;
 292 
					i++ ;
302 
				}
 293 
				}
303
294
304 
				// creation du store qui les contient
 295 
				// creation du store qui les contient
305
296
306 
				FieldDef defEtatObservation = new StringFieldDef("etat_observation");
 297 
				FieldDef defEtatObservation = new StringFieldDef("etat_observation");
307 
				FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
 298 
				FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
308 
				FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
 299 
				FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
309 
				FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
 300 
				FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
310 
				FieldDef defDateObservation = new StringFieldDef("date_observation");
 301 
				FieldDef defDateObservation = new StringFieldDef("date_observation");
311 
				FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
 302 
				FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
312
303
313 
				// on associe le store
 304 
				// on associe le store
314 
 
 305 
 
315 
				FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
 306 
				FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
316 
						defLieuObservation, defDateObservation, defOrdreObservation };
 307 
						defLieuObservation, defDateObservation, defOrdreObservation };
317
308
318 
				RecordDef rd = new RecordDef(defTab);
 309 
				RecordDef rd = new RecordDef(defTab);
319
310
320 
				final MemoryProxy dataProxy = new MemoryProxy(observationData);
 311 
				final MemoryProxy dataProxy = new MemoryProxy(observationData);
321 
				final ArrayReader reader = new ArrayReader(rd);
 312 
				final ArrayReader reader = new ArrayReader(rd);
322
313
323 
				final Store observationStore = new Store(dataProxy, reader);
 314 
				final Store observationStore = new Store(dataProxy, reader);
324
315
325
316
326 
				st = observationStore ;
 317 
				st = observationStore ;
327 
				st.load() ;
 318 
				st.load() ;
328
319
329 
				// par défaut le store est trié sur l'ordre d'observations
 320 
				// par défaut le store est trié sur l'ordre d'observations
330 
				st.sort("ordre_observation") ;
 321 
				st.sort("ordre_observation") ;
331 
 
 322 
 
332
323
333 
				// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
 324 
				// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour
334 
				if(repandreRafraichissement)
 325 
				if(repandreRafraichissement)
335 
				{
 326 
				{
336 
					listeObservation.rafraichir(st, false) ;
327 
					listeObservation.rafraichir(st, false) ;
337 
				}
 328 
				}
338
329
339 
		}
 330 
		}
340
331
341
332
342 
		// Si on reçoit un tableau d'entiers
 333 
		// Si on reçoit un tableau d'entiers
343 
		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
 334 
		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères
344 
		if(nouvelleDonnees instanceof int[])
 335 
		if(nouvelleDonnees instanceof int[])
345 
		{
 336 
		{
346 
			int[] pages = (int[])nouvelleDonnees ;
 337 
			int[] pages = (int[])nouvelleDonnees ;
347
338
348 
			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
 339 
			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle
349 
			pageMax  = calculerNbPages(pages[0]) ;
 340 
			pageMax  = calculerNbPages(pages[0]) ;
350 
			nbElements = pages[0] ;
 341 
			nbElements = pages[0] ;
351
342
352 
			// et on notifie de le mediateur du changement des valeurs
 343 
			// et on notifie de le mediateur du changement des valeurs
353 
			changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
 344 
			changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;
354
345
355 
			obtenirListeObservation();
 346 
			obtenirListeObservation();
356 
		}
 347 
		}
357 
	}
 348 
	}
358
349
359
350
360 
	/**
 351 
	/**
361 
	 * Met à jour les barre d'outils avec des nouvelles valeurs
 352 
	 * Met à jour les barre d'outils avec des nouvelles valeurs
362 
	 * @param pageMax le nombre de pages
 353 
	 * @param pageMax le nombre de pages
363 
	 * @param pageEncours la page en cours
 354 
	 * @param pageEncours la page en cours
364 
	 * @param taillePage la taille de page
 355 
	 * @param taillePage la taille de page
365 
	 * @param nbElement le nombre d'élements par page
 356 
	 * @param nbElement le nombre d'élements par page
366 
	 */
 357 
	 */
367 
	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
358 
	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement)
368 
	{
 359 
	{
369
360
370 
		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
 361 
		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;
371 
		listeObservation.getToolBarVue().rafraichir(pages, false) ;
 362 
		listeObservation.getToolBarVue().rafraichir(pages, false) ;
372
363
373 
	}
 364 
	}
374
365
375
366
376
367
377 
	/**
 368 
	/**
378 
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
 369 
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page
379 
	 * en cours
 370 
	 * en cours
380 
	 * @param nbElements le nombre d'élements total
 371 
	 * @param nbElements le nombre d'élements total
381 
	 * @return le nombre de pages
372 
	 * @return le nombre de pages
382 
	 */
 373 
	 */
383 
	public int calculerNbPages(int nbElements)
 374 
	public int calculerNbPages(int nbElements)
384 
	{
 375 
	{
385 
		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
 376 
		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement
386 
		// pour eviter qu'il arrondisse mal la division
 377 
		// pour eviter qu'il arrondisse mal la division
387 
		// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
 378 
		// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur
388
379
389 
		double nPage = (1.0*nbElements)/(1.0*taillePage) ;
380 
		double nPage = (1.0*nbElements)/(1.0*taillePage) ;
390 
		double nPageRound = Math.ceil(nPage) ;
 381 
		double nPageRound = Math.ceil(nPage) ;
391 
		Double nPageInt = new Double(nPageRound) ;
 382 
		Double nPageInt = new Double(nPageRound) ;
392
383
393 
		// on convertit en entier
 384 
		// on convertit en entier
394 
		return nPageInt.intValue() ;
385 
		return nPageInt.intValue() ;
395 
	}
 386 
	}
396 
 
 387 
 
397
388
398 
	/**
 389 
	/**
399 
	 * Recalcule la page en cours lors du changement du nombre d'élements
 390 
	 * Recalcule la page en cours lors du changement du nombre d'élements
400 
	 * @param nbElements le nombre d'élements total
 391 
	 * @param nbElements le nombre d'élements total
401 
	 * @return la nouvelle page encours
 392 
	 * @return la nouvelle page encours
402 
	 */
 393 
	 */
403 
	public int calculerPageCourante(int nbElements)
 394 
	public int calculerPageCourante(int nbElements)
404 
	{
 395 
	{
405 
		// on calcule le nombre de page
 396 
		// on calcule le nombre de page
406 
		int nouvelNbPages = calculerNbPages(nbElements) ;
 397 
		int nouvelNbPages = calculerNbPages(nbElements) ;
407 
		// la nouvelle page en cours
 398 
		// la nouvelle page en cours
408 
		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
 399 
		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;
409
400
410 
		// on arrondit au supérieur
 401 
		// on arrondit au supérieur
411 
		double nPageRound = Math.ceil(nPageCourante) ;
 402 
		double nPageRound = Math.ceil(nPageCourante) ;
412 
		Double nPageInt = new Double(nPageRound) ;
 403 
		Double nPageInt = new Double(nPageRound) ;
413
404
414 
		// on convertit en entier
 405 
		// on convertit en entier
415 
		return Math.abs(nPageInt.intValue()) ;
406 
		return Math.abs(nPageInt.intValue()) ;
416 
	}
 407 
	}
417
408
418 
 
 409 
 
419 
	/**
 410 
	/**
420 
	 * Appelle le modèle pour lui demander les données d'une page à afficher
 411 
	 * Appelle le modèle pour lui demander les données d'une page à afficher
421 
	 * @param pageCourante le numéro de page à affciher
 412 
	 * @param pageCourante le numéro de page à affciher
422 
	 */
 413 
	 */
423 
	public void changerNumeroPage(int pageCourante) {
 414 
	public void changerNumeroPage(int pageCourante) {
424
415
425
416
426
417
427 
		pageEncours = pageCourante ;
 418 
		pageEncours = pageCourante ;
428
419
429 
		// On lance le chargerment des observations
 420 
		// On lance le chargerment des observations
430 
		obtenirNombreObservation();
 421 
		obtenirNombreObservation();
431
422
432 
		listeObservation.getToolBarVue().changerPageCourante(pageCourante);
 423 
		listeObservation.getToolBarVue().changerPageCourante(pageCourante);
433
424
434 
	}
 425 
	}
435
426
436
427
437 
	/**
 428 
	/**
438 
	 * Appelle le modèle pour qu'il change la taille de page utilisée
 429 
	 * Appelle le modèle pour qu'il change la taille de page utilisée
439 
	 * @param nouvelleTaillePage la nouvelle taille de page
 430 
	 * @param nouvelleTaillePage la nouvelle taille de page
440 
	 */
 431 
	 */
441
432
442 
	public void changerTaillePage(int nouvelleTaillePage)
 433 
	public void changerTaillePage(int nouvelleTaillePage)
443 
	{
 434 
	{
444
435
445 
		taillePage = nouvelleTaillePage ;
 436 
		taillePage = nouvelleTaillePage ;
446 
		pageEncours = calculerPageCourante(nbElements) ;
 437 
		pageEncours = calculerPageCourante(nbElements) ;
447 
 
 438 
 
448 
		// 	On lance le chargerment des observations
 439 
		// 	On lance le chargerment des observations
449 
		obtenirNombreObservation();
 440 
		obtenirNombreObservation();
450
441
451
442
452 
		// et on met à jour la taille de page dans les barres d'outils
 443 
		// et on met à jour la taille de page dans les barres d'outils
453 
		listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
 444 
		listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);
454
445
455
446
456 
	}
 447 
	}
457 
 
 448 
 
458 
 
 449 
 
459 
	/**
 450 
	/**
460 
	 *
451 
	 *
461 
	 * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
452 
	 * Lance un appel de recherche d'une liste de commune correspondant aux criteres de selectionne
462 
	 * @param r : la vue demandeuse de donnee
 453 
	 * @param r : la vue demandeuse de donnee
463 
	 * @param critere : les criteres de selection
 454 
	 * @param critere : les criteres de selection
464 
	 */
 455 
	 */
465
456
466 
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
 457 
	public void obtenirListeReferentielCommune(Rafraichissable r, String critere) {
467
458
468 
		observationModele.obtenirListeReferentielCommune(r,critere) ;
 459 
		observationModele.obtenirListeReferentielCommune(r,critere) ;
469 
 
 460 
 
470
461
471 
	}
 462 
	}
472
463
473 
	/**
 464 
	/**
474 
	 *
465 
	 *
475 
	 * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
466 
	 * Lance un appel de recherche d'une liste de nom scientifique correspondant aux criteres de selectionne
476 
	 * @param r : la vue demandeuse de donnee
 467 
	 * @param r : la vue demandeuse de donnee
477 
	 * @param critere : les criteres de selection
 468 
	 * @param critere : les criteres de selection
478 
	 */
 469 
	 */
479
470
480 
	public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
 471 
	public void obtenirListeReferentielNom(Rafraichissable r, String critere) {
481
472
482 
		observationModele.obtenirListeReferentielNom(r,critere) ;
 473 
		observationModele.obtenirListeReferentielNom(r,critere) ;
483 
 
 474 
 
484
475
485 
	}
 476 
	}
486 
 
 477 
 
487
478
488 
	/**
 479 
	/**
489 
	 *
480 
	 *
490 
	 * Lance la creation d'une observation
481 
	 * Lance la creation d'une observation
491 
	 * @param r : la vue demandeuse de donnee
 482 
	 * @param r : la vue demandeuse de donnee
492 
	 * @param critere : les criteres de selection
 483 
	 * @param critere : les criteres de selection
493 
	 */
 484 
	 */
494
485
495 
	public void ajouterObservation(Rafraichissable r) {
 486 
	public void ajouterObservation(Rafraichissable r) {
496
487
497 
		observationModele.ajouterObservation(r) ;
 488 
		observationModele.ajouterObservation(r) ;
498
489
499 
	}
 490 
	}
500 
 
 491 
 
501
492
502
493
503 
 
 494 
 
504
495
505
496
506 
}
 497 
}