Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.vues.observation;

import java.util.Iterator;

import org.tela_botanica.client.modeles.objets.ListeObservation;

import org.tela_botanica.client.modeles.objets.Observation;

import org.tela_botanica.client.modeles.objets.Ontologies;

import org.tela_botanica.client.observation.ObservationMediateur;

import org.tela_botanica.client.util.Util;

import org.tela_botanica.client.vues.BarrePaginationVue;

import org.tela_botanica.client.interfaces.ListePaginable;

import org.tela_botanica.client.interfaces.Rafraichissable;

import org.tela_botanica.client.interfaces.VueListable;

import com.google.gwt.user.client.Window;

import com.gwtext.client.core.EventCallback;

import com.gwtext.client.core.EventObject;

import com.gwtext.client.core.Ext;

import com.gwtext.client.core.ExtElement;

import com.gwtext.client.core.SortDir;

import com.gwtext.client.data.ArrayReader;

import com.gwtext.client.data.FieldDef;

import com.gwtext.client.data.IntegerFieldDef;

import com.gwtext.client.data.MemoryProxy;

import com.gwtext.client.data.Record;

import com.gwtext.client.data.RecordDef;

import com.gwtext.client.data.SortState;

import com.gwtext.client.data.Store;

import com.gwtext.client.data.StringFieldDef;

import com.gwtext.client.dd.DragData;

import com.gwtext.client.dd.DragDropConfig;

import com.gwtext.client.dd.DragSource;

import com.gwtext.client.dd.DropTarget;

import com.gwtext.client.dd.DropTargetConfig;

import com.gwtext.client.widgets.Button;

import com.gwtext.client.widgets.Component;

import com.gwtext.client.widgets.Panel;

import com.gwtext.client.widgets.Tool;

import com.gwtext.client.widgets.Toolbar;

import com.gwtext.client.widgets.ToolbarButton;

import com.gwtext.client.widgets.ToolbarTextItem;

import com.gwtext.client.widgets.event.ButtonListenerAdapter;

import com.gwtext.client.widgets.event.PanelListenerAdapter;

import com.gwtext.client.widgets.grid.CellMetadata;

import com.gwtext.client.widgets.grid.ColumnConfig;

import com.gwtext.client.widgets.grid.ColumnModel;

import com.gwtext.client.widgets.grid.GridPanel;

import com.gwtext.client.widgets.grid.Renderer;

import com.gwtext.client.widgets.grid.event.GridHeaderListenerAdapter;

import com.gwtext.client.widgets.grid.event.GridListenerAdapter;

import com.gwtext.client.widgets.grid.event.GridRowListenerAdapter;

import com.gwtext.client.widgets.tree.TreeDragData;

import com.gwtext.client.widgets.tree.TreeNode;

/**

 * Liste d'observation composée de ligne d'observation

 * l'interface rafraichissable et l'interface vueListable

 *

 * @author David Delon 2008

 */

public class ListeObservationVue extends GridPanel implements Rafraichissable,

		VueListable, ListePaginable {

	/**

	 * Le médiateur associé à la vue

	 */

	private ObservationMediateur	observationMediateur		= null;

	/**

	 * Config de colonne

	 */

	private ColumnConfig	etatObservation;

	private ColumnConfig	referentielTaxoObservation;

	private ColumnConfig	nomSaisiObservation;

	private ColumnConfig	nomRetenuObservation;

	private ColumnConfig	familleObservation;

	private ColumnConfig	lieuObservation;

	private ColumnConfig	altitudeObservation;

	private ColumnConfig	dateObservation;

	private ColumnConfig	ordreObservation;

	private ColumnConfig 	abondanceObservation;

	private ColumnConfig 	certitudeObservation;

	private ColumnModel		modeleColonnes;

	/**

	 * Store qui contient les données à afficher

	 */

	private Store			st				= null;

	/**

	 * Barre de pagination

	 */

	private BarrePaginationVue bt = null ;

	/**

	 * Numéro de page en cours

	 */

	private int pageEncours = 0 ;

	/**

	 * Nombre de pages totales

	 */

	private int pageMax = 1 ;

	/**

	 * Taille de page (par défaut 20)

	 */

	private int taillePage = 20 ;

	/**

	 * Nombre d'éléments total correspondant à la requete

	 */

	private int nbElements = 0 ;

	private ListeObservation cacheListeObservation = null;

	private Tool exporterObservations = null ;

	private final int KEY_ENTER = 13;

	private String modeleLieu = "IDLOCCOMMUNE, LIEUDIT, STATION";

	private boolean tailleInitialisee = false ;

	private ColumnConfig phenologieObservation;

	private SortDir directionTri;

	private String champTri;

	private boolean triActif;

	/**

	 * Constructeur sans arguments (privé car ne doit pas être utilisé)

	 */

	@SuppressWarnings("unused")

	private ListeObservationVue()

	{

		super() ;

	}

	/**

	 * Constructeur avec argument

	 * @param im le médiateur à associer

	 */

	public ListeObservationVue(ObservationMediateur obs) {

		this.observationMediateur = obs;

		setId("x-list-obs");

		setHeader(true);

		// on place la barre de pagination

		bt = new BarrePaginationVue(this);

		bt.setLabelElement("Observations");

		bt.setTaillePageParDefaut(20);

		bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ;

		Toolbar barreActions = new Toolbar();

		ToolbarButton publier = new ToolbarButton("Rendre publiques");

		publier.addListener(new ButtonListenerAdapter() {

			@Override

			public void onClick(Button b, EventObject e) {

				observationMediateur.transmettreObservations(true);

			}

		});

		ToolbarButton privatiser = new ToolbarButton("Rendre privées");

		privatiser.addListener(new ButtonListenerAdapter() {

			@Override

			public void onClick(Button b, EventObject e) {

				observationMediateur.transmettreObservations(false);

			}

		});

		ToolbarButton supprimer = new ToolbarButton("Supprimer");

		supprimer.addListener(new ButtonListenerAdapter() {

			@Override

			public void onClick(Button b, EventObject e) {

				observationMediateur.supprimerObservations();

			}

		});

		ToolbarButton importer = new ToolbarButton("Importer");

		importer.addListener(new ButtonListenerAdapter() {

			@Override

			public void onClick(Button b, EventObject e) {

				observationMediateur.afficherFormulaireImportObservation();

			}

		});

		ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> Exporter </a>");

 		ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"Génération d'étiquettes au format PDF pour la sélection\"> Étiquettes </a>");

		barreActions.addButton(publier);

		barreActions.addButton(privatiser);

		barreActions.addSpacer();

		barreActions.addButton(supprimer);

		barreActions.addSpacer();

		barreActions.addButton(importer);

		barreActions.addSpacer();

		barreActions.addItem(exporter);

		barreActions.addItem(exporterPDF);

		this.setTopToolbar(barreActions) ;

		this.setBottomToolbar(bt);

		this.setCollapsible(true);

		this.setTitleCollapse(true);

		this.setTitle("Observations") ;

		modeleColonnes = new ColumnModel(getConfigColonnes());

		this.setColumnModel(modeleColonnes);

		this.setAutoScroll(true);

		this.setEnableColumnResize(true);

		// creation du store

		RecordDef rd = new RecordDef(getDefinitionChamps());

		st = new Store(rd);

		// on associe le store

		this.setStore(st);

		this.getView().setAutoFill(true);

		this.getView().setForceFit(true) ;

		// on crée un masque de chargement qui s'affichera lors des mises à jour

		this.setLoadMask("Chargement");

		// on ajoute les listeners

		ajouterListeners();

		configDragAndDrop();

	}

	private ColumnConfig[] getConfigColonnes() {

		// on construit le modèle de colonnes

		// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir)

		Renderer colRend = new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				String valeur = "";

				if(value != null && !value.equals("null") && !value.equals("000null") && !value.equals("0000-00-00 00:00:00")) {

					valeur = value.toString() ;

				}

				return valeur;

			}

		} ;

		Renderer dateRend = new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {

					return "" ;

				}

				else

				{

					String dateEntiere = value.toString() ;

					String[] dateEtHeure = dateEntiere.split(" ", 2);

					if(verifierFormatDate(dateEtHeure[0])) {

						String[] dateFormateeTab = dateEtHeure[0].split("-",3);

						return dateFormateeTab[2]+"/"+dateFormateeTab[1]+"/"+dateFormateeTab[0] ;

					}

				}

				return value.toString() ;

			}

		} ;

		etatObservation = new ColumnConfig("Transmis", "etat_observation", 20, true, new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				if(value.equals("1"))

				{

					return "<img src=\"tela.png\"/></img>" ;

				}

				else

				{

					return "" ;

				}

			}

		});

		referentielTaxoObservation = new ColumnConfig("Référentiel", "referentiel_taxo_observation", 15, true, colRend);

		nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 130, true, colRend);

		nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 130, true, colRend);

		familleObservation = new ColumnConfig("Famille", "famille_observation", 50, true, colRend);

		lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 130, true, colRend);

		altitudeObservation = new ColumnConfig("Alt", "altitude_observation", 10, true, colRend);

		dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend);

		abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend);

		certitudeObservation = new ColumnConfig("Identification", "certitude", 50, true, new Renderer() {

			@Override

			public String render(Object value, CellMetadata cellMetadata,

					Record record, int rowIndex, int colNum, Store store) {

				return Ontologies.getCorrespondanceCertitude(record.getAsString("certitude"));

			}

		});

		phenologieObservation = new ColumnConfig("Phénologie", "phenologie", 40, true, colRend);

		ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 70, true, colRend);

		ColumnConfig[] cm = {etatObservation, referentielTaxoObservation,

							 nomSaisiObservation, certitudeObservation,

							 nomRetenuObservation, familleObservation,

							 abondanceObservation, phenologieObservation,

							 lieuObservation, altitudeObservation,

							 dateObservation, ordreObservation};

		return cm;

	}

	/**

	 * Ajoute les listeners pour la gestion des évènements

	 */

	private void ajouterListeners() {

		this.addGridHeaderListener(new GridHeaderListenerAdapter() {

			@Override

			public void onHeaderClick(GridPanel grid, int colIndex, EventObject e) {

				triActif = true;

			}

		});

		this.addGridRowListener(new GridRowListenerAdapter() {

			// gestion du clic sur une ligne

			@Override

			public void onRowClick(GridPanel grid, int rowIndex,

					EventObject e) {

				// on notifie le médiateur et on lui passe le numéro de ligne

				Record rd = st.getAt(rowIndex);

				String ordreObservation = rd.getAsString("ordre_observation") ;

				observationMediateur.onClicListeObservation(rowIndex,ordreObservation);

			}

			// gestion du clic droit

			@Override

			public void onRowContextMenu(GridPanel grid, int rowIndex,

					EventObject e) {

				// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu

				e.stopEvent() ;

				// on notifie le médiateur en lui passant l'évenement

				observationMediateur.montrerContextMenu(e);

			}

			// gestion du double clic

			@Override

			public void onRowDblClick(GridPanel grid, int rowIndex,

					EventObject e) {

				// on notifie le médiateur en lui passant le numéro de ligne

				observationMediateur.doubleClicListeObservation(rowIndex);

			}

		});

		this.addGridListener(new GridListenerAdapter() {

			@Override

			public void onKeyPress(EventObject e) {

				if(e.getKey() == KEY_ENTER) {

					Record rd = getSelectionModel().getSelected();

					int rowIndex = st.indexOf(rd);

					String ordreObservation = rd.getAsString("ordre_observation") ;

					observationMediateur.onClicListeObservation(rowIndex, ordreObservation);

				}

			}

		});

		this.addListener(new PanelListenerAdapter() {

			@Override

			public void onRender(Component c) {

				ExtElement lienExport = Ext.get("lienExport") ;

				lienExport.addListener("click", new EventCallback() {

					@Override

					public void execute(EventObject e) {

						observationMediateur.exporterObservations();

					}

				});

				ExtElement lienExportPDF = Ext.get("lienExportPDF") ;

				lienExportPDF.addListener("click", new EventCallback() {

					@Override

					public void execute(EventObject e) {

						observationMediateur.exporterObservationsPDF();

					}

				});

			}

		});

		this.addListener(new PanelListenerAdapter() {

			@Override

			public void onBodyResize(Panel panel, java.lang.String width, java.lang.String height) {

				doLayout();

			}

		});

	}

	/**

	 * Configure le drag 'n drop pour la liste

	 */

	private void configDragAndDrop()

	{

		setDdGroup("ObsMotsClesGroup");

		setEnableDragDrop(true);

		setDragDropText("Glissez les observations sélectionnées sur un projet pour les lier");

		// on fabrique la nouvelle configuration

		// les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup

		DropTargetConfig dtc = new DropTargetConfig();

		dtc.setdDdGroup("ObsMotsClesGroup");

		dtc.setTarget(true);

		DragDropConfig ddc = new DragDropConfig();

		//La drop target permet de gérer l'évenement onDrop sur l'élement courant

		@SuppressWarnings("unused")

		DropTarget tg = new DropTarget(this, dtc)

		{

			@Override

			public boolean notifyDrop(DragSource source, EventObject e, DragData data){

				// si on reçoit des données provenant d'un arbre

				// on les convertit

				if(data instanceof TreeDragData)  {

			    	TreeDragData tdd = (TreeDragData)data ;

			    	TreeNode treeNode = tdd.getTreeNode();

			    	String idMc = treeNode.getId();

			    	int index = getView().findRowIndex(e);

			    	if(index < 0) {

			    		return true;

			    	}

			    	Record obsRd = getStore().getRecordAt(index);

			    	if(obsRd == null) {

			    		return true;

			    	}

			    	String ordreObs = obsRd.getAsString("ordre_observation");

			    	if(ordreObs != null) {

			    		observationMediateur.gererDDMotCleSurObs(ordreObs, idMc);

			    		return true ;

			    	} else {

			    		return true;

			    	}

				}

		    	return true;

			}

			@Override

			public String notifyOver(DragSource source, EventObject e, DragData data){

				if(data instanceof TreeDragData)  {

			    	TreeDragData tdd = (TreeDragData)data ;

			    	TreeNode treeNode = tdd.getTreeNode();

			    	String idMc = treeNode.getId();

			    	int index = getView().findRowIndex(e);

			    	if(index < 0) {

			    		return "x-dd-drop-nodrop";

			    	}

			    	Record obsRd = getStore().getRecordAt(index);

			    	if(obsRd == null) {

			    		return "x-dd-drop-nodrop";

			    	}

			    	String ordreObs = obsRd.getAsString("ordre_observation");

			    	if(ordreObs != null) {

			    		return observationMediateur.gererOverDDMotCleSurObs(ordreObs, idMc);

			    	}

				}

				return "x-dd-drop-nodrop";

			}

		};

	}

	/**

	 * Méthode héritée de l'interface VueListable

	 * Sélectionne les observations  dans la liste suivant les identifiants donnés en paramètres

	 */

	@Override

	public String[] getIdSelectionnees() {

		Record[] selection = this.getSelectionModel().getSelections();

		int taille = selection.length;

		String id_selection[] = new String[taille];

		for (int i = 0; i < selection.length; i++) {

			id_selection[i] = selection[i].getAsString("ordre_observation");

		}

		return id_selection;

	}

	/**

	 * Sélectionne des enregistrements donné

	 * @param sel un tableau d'enregistrement à selectionner

	 */

	public void selectionnerEnregistrements(Record[] sel) {

			getSelectionModel().clearSelections();

			getSelectionModel().selectRecords(sel);

	}

	/**

	 * Accesseur pour la toolbar de pagination

	 * @return la toolbar de pagination

	 */

	public BarrePaginationVue getToolBarVue()

	{

		return bt ;

	}

	/**

	 * Recherche l'élement actuellement affiché et affiche son message de chargement

	 */

	public void masquerChargement()

	{

		ExtElement masked = Ext.get(getId()) ;

		if (masked!=null) {

			masked.mask("Chargement") ;

		}

	}

	/**

	 * Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché

	 */

	public void demasquerChargement()

	{

		ExtElement masked = Ext.get(getId()) ;

		if (masked!=null) {

			masked.unmask() ;

		}

	}

	/**

	 * Méthode héritée de l'interface rafraichissable

	 * @param nouvelleDonnees les nouvelles données

	 * @param repandreRafraichissement le booleen de notification du rafraichissement

	 */

	@Override

	public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) {

		// si l'on a reçu une liste d'observation

		if(nouvelleDonnees instanceof ListeObservation)

		{

				ListeObservation data = (ListeObservation) nouvelleDonnees ;

				Object[][] observationData = new Object[data.size()][13];

				int i = 0 ;

				if(data.size() == 0)

				{

					pageEncours = 0 ;

				}

				// on la parse et on récupère les informations qui nous interessent

				for (Iterator it = data.keySet().iterator(); it.hasNext();)

				{

					Observation obs=data.get(it.next());

					observationData[i][0] = obs.getTransmis();

					observationData[i][1] = obs.getCodeCourtReferentielTaxo();

					observationData[i][2] = obs.getNomSaisi();

					observationData[i][3] = obs.getCertitude();

					observationData[i][4] = obs.getNomRetenu();

					observationData[i][5] = obs.getFamille();

					observationData[i][6] = obs.getAbondance();

					observationData[i][7] = obs.getPhenologie();

					observationData[i][8] = Util.formaterLieu(obs, modeleLieu);

					observationData[i][9] = formaterAltitude(obs.getAltitude());

					observationData[i][10] = obs.getDate();

					observationData[i][11] = obs.getNumeroOrdre();

					observationData[i][12] = obs.getNumeroNomenclaturalSaisi();

					i++ ;

				}

				RecordDef rd = new RecordDef(getDefinitionChamps());

				final MemoryProxy dataProxy = new MemoryProxy(observationData);

				final ArrayReader reader = new ArrayReader(rd);

				final Store observationStore = new Store(dataProxy, reader);

				st = observationStore ;

				st.load() ;

				// et on reconfigure et rafraichit la vue

				this.reconfigure(st, this.getColumnModel());

				demasquerChargement();

			    cacheListeObservation=data;

				observationMediateur.onRafraichissementListeObservations();

		}

		// Si on reçoit un tableau d'entiers

		// c'est un tableau d'un seul entier qui est le nombre d'observation correspondant aux critères

		if(nouvelleDonnees instanceof int[])

		{

			int[] pages = (int[])nouvelleDonnees ;

			// on calcule le nombre de pages nécessaires et on les met à jour dans le modèle

			pageMax  = calculerNbPages(pages[0]) ;

			nbElements = pages[0] ;

			// et on notifie de le mediateur du changement des valeurs

			changerPageMaxEtCourante(pageMax,pageEncours,taillePage,pages[0]) ;

			if(nbElements > 0) {

				masquerChargement();

				observationMediateur.obtenirListeObservation(this);

			} else {

				this.rafraichir(new ListeObservation(0), false);

			}

		}

		// si l'on a reçu une Observation

		if(nouvelleDonnees instanceof Observation) {

			// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri

			// on l'enregistre donc avant suppression

			enregistrerEtatTri();

			Observation obs= (Observation) nouvelleDonnees;

			if (obs.getNumeroOrdre()==null) {

				// Nouvelle observation

				// On affiche la dernière page

				pageEncours = pageMax ;

				masquerChargement();

				observationMediateur.obtenirNombreObservation();

			}

			else { // Modification d'une observation

				masquerChargement();

				observationMediateur.obtenirNombreObservation();

			}

		}

		// Si on a effectué une suppression

		if(nouvelleDonnees instanceof String)

		{

			// la modification ou suppression d'un élément dans la liste provoque un bug sur l'état du tri

			// on l'enregistre donc avant suppression

			enregistrerEtatTri();

			observationMediateur.obtenirNombreObservation() ;

		}

		if(!getTailleInitialisee()) {

			if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {

				doLayout();

				setTailleInitialisee();

			}

		}

		// réaffectation du tri courant si nécessaire

		if(directionTri != null && champTri != null) {

			st.sort(champTri, directionTri);

		}

	}

	private String formaterAltitude(String alt) {

		String alfFmt = Util.formaterNombre(alt);

		if(!alfFmt.isEmpty() && !Util.estZero(alfFmt)) {

			alfFmt = alfFmt+" m.";

		}

		return alfFmt;

	}

	private FieldDef[] getDefinitionChamps() {

		// creation du store qui les contient

		FieldDef defEtatObservation = new StringFieldDef("etat_observation");

		FieldDef defRefTaxObservation = new StringFieldDef("referentiel_taxo_observation");

		FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");

		FieldDef defCertitudeObservation = new StringFieldDef("certitude");

		FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");

		FieldDef defFamilleObservation = new StringFieldDef("famille_observation");

		FieldDef defAbondanceObservation = new StringFieldDef("abondance");

		FieldDef defPhenologieObservation = new StringFieldDef("phenologie");

		FieldDef defLieuObservation = new StringFieldDef("lieu_observation");

		FieldDef defAltObservation = new StringFieldDef("altitude_observation");

		FieldDef defDateObservation = new StringFieldDef("date_observation");

		FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");

		// Non affiches :

		FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");

		FieldDef[] defTab = {defEtatObservation, defRefTaxObservation,defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defFamilleObservation, defAbondanceObservation,

				defPhenologieObservation, defLieuObservation, defAltObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };

		return defTab;

	}

	// GESTION DE LA PAGINATION

	public ListeObservation getCacheListeObservation() {

		return cacheListeObservation;

	}

	/**

	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page

	 * en cours

	 * @param nbElements le nombre d'élements total

	 * @return le nombre de pages

	 */

	public int calculerNbPages(int nbElements)

	{

		// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement

		// pour eviter qu'il arrondisse mal la division

		// nombre de pages = (nombre d'element / taille de la page) arrondi à l'entier superieur

		double nPage = (1.0*nbElements)/(1.0*taillePage) ;

		double nPageRound = Math.ceil(nPage) ;

		Double nPageInt = new Double(nPageRound) ;

		return nPageInt.intValue() ;

	}

	/**

	 * Recalcule la page en cours lors du changement du nombre d'élements

	 * @param nbElements le nombre d'élements total

	 * @return la nouvelle page encours

	 */

	public int calculerPageCourante(int nbElements)

	{

		// on calcule le nombre de page

		int nouvelNbPages = calculerNbPages(nbElements) ;

		// la nouvelle page en cours

		double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ;

		// on arrondit au supérieur

		double nPageRound = Math.ceil(nPageCourante) ;

		Double nPageInt = new Double(nPageRound) ;

		return Math.abs(nPageInt.intValue()) ;

	}

	/**

	 * Appelle le modèle pour lui demander les données d'une page à afficher

	 * @param pageCourante le numéro de page à affciher

	 */

	@Override

	public void changerNumeroPage(int pageCourante) {

		pageEncours = pageCourante ;

		masquerChargement();

		enregistrerEtatTri();

		// On lance le chargerment des observations

		observationMediateur.obtenirNombreObservation();

		getToolBarVue().changerPageCourante(pageCourante);

	}

	/**

	 * Appelle le modèle pour qu'il change la taille de page utilisée

	 * @param nouvelleTaillePage la nouvelle taille de page

	 */

	@Override

	public void changerTaillePage(int nouvelleTaillePage) {

		taillePage = nouvelleTaillePage ;

		pageEncours = calculerPageCourante(nbElements) ;

		enregistrerEtatTri();

		masquerChargement();

		// 	On lance le chargement des observations

		observationMediateur.obtenirNombreObservation();

		// et on met à jour la taille de page dans les barres d'outils

		getToolBarVue().selectionnerTaillePage(nouvelleTaillePage);

	}

	/**

	 * Met à jour les barre d'outils avec des nouvelles valeurs

	 * @param pageMax le nombre de pages

	 * @param pageEncours la page en cours

	 * @param taillePage la taille de page

	 * @param nbElement le nombre d'élements par page

	 */

	public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) {

		int[] pages = {pageMax,pageEncours, taillePage, nbElement} ;

		getToolBarVue().rafraichir(pages, false) ;

	}

	/**

	 * Renvoie la taille de page en cours d'utilisation

	 * @return la taille de page

	 */

	public int getTaillePage() {

		return taillePage;

	}

	/**

	 * Renvoie le numéro de la page encours (attention on commence à 0)

	 * @return le numéro de la page en cours

	 */

	public int getPageEncours() {

		return pageEncours;

	}

	private void enregistrerEtatTri() {

		if(triActif) {

			this.directionTri = st.getSortState().getDirection();

			this.champTri = st.getSortState().getField();

		}

	}

	public void afficherFiltres(String[][] filtresEnCours) {

		String texteFiltresEnCours = "";

		for(int i = 0; i < filtresEnCours.length; i++) {

			if(Util.filtreValide(filtresEnCours[i])) {

				if(!texteFiltresEnCours.equals("")) {

					texteFiltresEnCours += " - ";

				}

				texteFiltresEnCours += "<span class=\"affichage_filtre\">"+

											transformerNomFiltre(filtresEnCours[i][0])+": "+transformerValeurFiltre(filtresEnCours[i][0], filtresEnCours[i][1])+

									   " <input value=\"X\" type=\"button\" rel=\""+filtresEnCours[i][0]+"\" id=\"bouton_raz_filtres_obs_"+filtresEnCours[i][0]+"\" />"+

										"</span>";

			}

		}

		if(!texteFiltresEnCours.equals("")) {

			texteFiltresEnCours = "- <span class=\"indicateur_filtres\"> Filtres - "+texteFiltresEnCours+"</span>";

		}

		this.setTitle("Observations"+texteFiltresEnCours) ;

		for(int i = 0; i < filtresEnCours.length; i++) {

			if(Util.filtreValide(filtresEnCours[i])) {

				if(Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]) != null) {

					Ext.get("bouton_raz_filtres_obs_"+filtresEnCours[i][0]).addListener("click", new EventCallback() {

						@Override

						public void execute(EventObject e) {

							e.stopEvent();

							observationMediateur.viderFiltre(e.getTarget().getAttribute("rel"));

						}

					});

				}

			}

		}

	}

	private String transformerNomFiltre(String nomFiltre) {

		if(nomFiltre.equals("departement")) {

			nomFiltre = "departement";

		}

		if(nomFiltre.equals("commune")) {

			nomFiltre = "commune";

		}

		if(nomFiltre.equals("nom_taxon")) {

			nomFiltre = "recherche";

		}

		if(nomFiltre.equals("id_mots_cles")) {

			nomFiltre = "projets";

		}

		return nomFiltre;

	}

	private String transformerValeurFiltre(String nomFiltre, String valeurFiltre) {

		String valeurFiltreTransformee = valeurFiltre;

		if(nomFiltre.equals("id_mots_cles")) {

			String[] tabMotsCles = valeurFiltre.split(";");

			String[] tabMotsClesTexte = observationMediateur.obtenirTexteMotsCles(tabMotsCles);

			if(tabMotsClesTexte.length > 1) {

				valeurFiltreTransformee = Util.implode(",", tabMotsClesTexte);

			} else {

				valeurFiltreTransformee = tabMotsClesTexte[0];

			}

		}

		if(nomFiltre.equals("mois")) {

			valeurFiltreTransformee = Util.renvoyerMois(Integer.parseInt(valeurFiltre));

		}

		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("000null", "inconnue");

		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", "inconnue");

		valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", "inconnue");

		return valeurFiltreTransformee;

	}

	public void raz() {

		RecordDef rd = new RecordDef(getDefinitionChamps());

		st = new Store(rd);

		// on associe le store

		this.setStore(st);

	}

	public boolean verifierFormatDate(String date) {

		String regex = "[1-9][0-9]{3}-[0-9]{2}-[0-9]{2}" ;

		if(date.matches(regex) && !date.equals("0000-00-00")) {

			return true ;

		}

		else {

			return false;

		}

	}

	public boolean getTailleInitialisee() {

		return tailleInitialisee ;

	}

	public void setTailleInitialisee() {

		tailleInitialisee = true;

	}

}