WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java

 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.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.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.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.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;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig	nomSaisiObservation;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig	nomRetenuObservation;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig	lieuObservation;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig	dateObservation;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig	ordreObservation;
 	/**
 	 * Config de colonne
 	 */
 	private ColumnConfig abondanceObservation;
+	/**
+	 * Config de colonne
+	 */
+	private ColumnConfig certitudeObservation;
 	/**
 	 * Modele de colonnes
 	 */
 	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 ;
 	/**
 	 * 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>");
 		barreActions.addButton(publier);
 		barreActions.addButton(privatiser);
 		barreActions.addSpacer();
 		barreActions.addButton(supprimer);
 		barreActions.addSpacer();
 		barreActions.addButton(importer);
 		barreActions.addSpacer();
 		barreActions.addItem(exporter);
 		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
 		// 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)
 		// 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) {
 				if(value == null || value.equals("null") || value.equals("000null") || value.equals("0000-00-00 00:00:00")) {
 					return "" ;
+				}
 				else
+				{
+				}
 				return value.toString() ;
+			}
 		} ;
 		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 "" ;
+				}
+			}
 		});
 		nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200, true, colRend);
 		nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200, true, colRend);
 		lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200, true, colRend);
 		dateObservation = new ColumnConfig("Date", "date_observation", 70, true, dateRend);
 		abondanceObservation = new ColumnConfig("Abondance", "abondance", 50, true, colRend);
-		ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 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"));
+			}
+		});
+		ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50, true, colRend);
-		// on associe le modèle de colonnes
-		ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, abondanceObservation, lieuObservation, dateObservation, ordreObservation};
-		modeleColonnes = new ColumnModel(cm);
-		this.setColumnModel(modeleColonnes);
-		this.setAutoScroll(true);
-		this.setEnableColumnResize(true);
-		// creation du store
-		FieldDef defEtatObservation = new StringFieldDef("etat_observation");
-		FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
-		FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
-		FieldDef defAbondanceObservation = new IntegerFieldDef("abondance");
-		FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
-		FieldDef defDateObservation = new StringFieldDef("date_observation");
-		FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
-		FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
-				defAbondanceObservation, defLieuObservation, defDateObservation, defOrdreObservation };
-		RecordDef rd = new RecordDef(defTab);
-		st = new Store(rd);
-		// on associe le store
+		ColumnConfig[] cm = {etatObservation, nomSaisiObservation, certitudeObservation, nomRetenuObservation, abondanceObservation, lieuObservation, dateObservation, ordreObservation};
-		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();
 		return cm;
+	}
 	/**
 	 * Ajoute les listeners pour la gestion des évènements
 	 */
 	private void ajouterListeners() {
 		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();
+					}
 				});
+			}
 		});
 		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()) ;
+		ExtElement masked = Ext.get(getId()) ;
-			if (masked!=null) {
-				masked.mask("Chargement") ;
-			}
+		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
+		// si l'on a reçu une liste d'observation
 		if(nouvelleDonnees instanceof ListeObservation)
 		{
 				ListeObservation data = (ListeObservation) nouvelleDonnees ;
-				Object[][] observationData = new Object[data.size()][8];
+				Object[][] observationData = new Object[data.size()][9];
 				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.getNomSaisi();
+					observationData[i][2] = obs.getCertitude();
-					observationData[i][2] = obs.getNomRetenu();
+					observationData[i][3] = obs.getNomRetenu();
-					observationData[i][3] = obs.getAbondance();
+					observationData[i][4] = obs.getAbondance();
-					observationData[i][4] = Util.formaterLieu(obs, modeleLieu);
+					observationData[i][5] = Util.formaterLieu(obs, modeleLieu);
-					observationData[i][5] = obs.getDate();
+					observationData[i][6] = obs.getDate();
-					observationData[i][6] = obs.getNumeroOrdre();
+					observationData[i][7] = obs.getNumeroOrdre();
-					observationData[i][7] = obs.getNumeroNomenclaturalSaisi();
+					observationData[i][8] = obs.getNumeroNomenclaturalSaisi();
 					i++ ;
+				}
-				// creation du store qui les contient
-				FieldDef defEtatObservation = new StringFieldDef("etat_observation");
-				FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
-				FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
-				FieldDef defAbondanceObservation = new StringFieldDef("abondance");
-				FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
-				FieldDef defDateObservation = new StringFieldDef("date_observation");
-				FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
-				// Non affiches :
-				FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
-				// on associe le store
-				FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, defAbondanceObservation,
-						defLieuObservation, defDateObservation, defOrdreObservation, defNumeroNomenclaturalSaisiObservation };
-				RecordDef rd = new RecordDef(defTab);
+				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]) ;
 			masquerChargement();
 			observationMediateur.obtenirListeObservation(this);
+		}
 		// si l'on a reçu une Observation
 		if(nouvelleDonnees instanceof Observation) {
 			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)
+		{
 			observationMediateur.obtenirNombreObservation() ;
+		}
 		if(!getTailleInitialisee()) {
 			if((int)Math.round(observationMediateur.getPanneauPrincipalObservation().getHeight() * 0.6) != 0) {
 				doLayout();
 				setTailleInitialisee();
+			}
+		}
+	}
+	private FieldDef[] getDefinitionChamps() {
+		// creation du store qui les contient
+		FieldDef defEtatObservation = new StringFieldDef("etat_observation");
+		FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
+		FieldDef defCertitudeObservation = new StringFieldDef("certitude");
+		FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
+		FieldDef defAbondanceObservation = new StringFieldDef("abondance");
+		FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
+		FieldDef defDateObservation = new StringFieldDef("date_observation");
+		FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
+		// Non affiches :
+		FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
+		FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defCertitudeObservation, defNomRetenuObservation, defAbondanceObservation,
+				defLieuObservation, 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) arrondie à l'entier superieur
+		// 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) ;
 		// on convertit en entier
 		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) ;
 		// on convertit en entier
 		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();
 		// 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)
+	public void changerTaillePage(int nouvelleTaillePage) {
-	{
 		taillePage = nouvelleTaillePage ;
 		pageEncours = calculerPageCourante(nbElements) ;
 		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);
 		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)
+	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;
+	}
 	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() {
-		// creation du store qui les contient
-		FieldDef defEtatObservation = new StringFieldDef("etat_observation");
-		FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
-		FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
-		FieldDef defAbondanceObservation = new IntegerFieldDef("abondance");
-		FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
-		FieldDef defDateObservation = new StringFieldDef("date_observation");
-		FieldDef defOrdreObservation = new IntegerFieldDef("ordre_observation");
-		// Non affiches :
-		FieldDef defNumeroNomenclaturalSaisiObservation = new StringFieldDef("numeroNomenclaturalSaisi_observation");
-		FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
-				defAbondanceObservation, defLieuObservation, defDateObservation, defOrdreObservation };
+	public void raz() {
-		RecordDef rd = new RecordDef(defTab);
+		RecordDef rd = new RecordDef(getDefinitionChamps());
-		st = new Store(rd);
 		st = new Store(rd);
-		// on associe le store
+		// on associe le store
-		this.setStore(st);
 		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;
+	}
+}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java @ 3898 – Rev 1488 → 1489