| New file |
|---|
| 0,0 → 1,1002 |
|---|
| package org.tela_botanica.client.vues.observation; |
| |
| |
| import java.util.HashMap; |
| 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.i18n.Msg; |
| 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.Event; |
| import com.google.gwt.user.client.Timer; |
| 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 = "IDLOCLOCALITE, 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(Msg.get("observations")); |
| bt.setTaillePageParDefaut(20); |
| bt.setIntervallesPages(new String[] {"1000","400","200","100","50","20","10"}) ; |
| |
| Toolbar barreActions = new Toolbar(); |
| ToolbarButton publier = new ToolbarButton(Msg.Get("rendre-publiques")); |
| publier.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(true); |
| } |
| }); |
| |
| ToolbarButton privatiser = new ToolbarButton(Msg.Get("rendre-privees")); |
| privatiser.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.transmettreObservations(false); |
| } |
| }); |
| |
| ToolbarButton supprimer = new ToolbarButton(Msg.get("supprimer")); |
| supprimer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.supprimerObservations(); |
| } |
| }); |
| |
| ToolbarButton importer = new ToolbarButton(Msg.get("importer")); |
| importer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button b, EventObject e) { |
| observationMediateur.afficherFormulaireImportObservation(); |
| } |
| }); |
| |
| ToolbarTextItem exporter = new ToolbarTextItem("<a href=\"#\" id=\"lienExport\"> " + Msg.get("exporter") + " </a>"); |
| ToolbarTextItem exporterFull = new ToolbarTextItem("<a href=\"#\" id=\"lienExportFull\" title=\"" + Msg.get("export-nc-ce-bf-bv") + "\"> " + Msg.get("export-etendu") + " </a>"); |
| ToolbarTextItem exporterPDF = new ToolbarTextItem("<a href=\"#\" id=\"lienExportPDF\" title=\"" + Msg.get("etiquettes-pdf") + "\"> " + Msg.get("etiquettes") + " </a>"); |
| |
| barreActions.addButton(publier); |
| barreActions.addButton(privatiser); |
| barreActions.addSpacer(); |
| barreActions.addButton(supprimer); |
| barreActions.addSpacer(); |
| barreActions.addButton(importer); |
| barreActions.addSpacer(); |
| barreActions.addItem(exporter); |
| barreActions.addItem(exporterFull); |
| barreActions.addItem(exporterPDF); |
| |
| this.setTopToolbar(barreActions) ; |
| this.setBottomToolbar(bt); |
| |
| this.setCollapsible(true); |
| this.setTitleCollapse(true); |
| |
| this.setTitle(Msg.get("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(Msg.get("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(Msg.get("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(Msg.get("referentiel"), "referentiel_taxo_observation", 15, true, colRend); |
| nomSaisiObservation = new ColumnConfig(Msg.get("nom-saisi"), "nomSaisi_observation", 130, true, colRend); |
| nomRetenuObservation = new ColumnConfig(Msg.get("nom-retenu"), "nomRetenu_observation", 130, true, colRend); |
| familleObservation = new ColumnConfig(Msg.get("famille"), "famille_observation", 50, true, colRend); |
| lieuObservation = new ColumnConfig(Msg.get("lieu"), "lieu_observation", 130, true, colRend); |
| altitudeObservation = new ColumnConfig(Msg.Get("altitude-court"), "altitude_observation", 10, true, colRend); |
| dateObservation = new ColumnConfig(Msg.get("date"), "date_observation", 70, true, dateRend); |
| abondanceObservation = new ColumnConfig(Msg.get("abondance"), "abondance", 50, true, colRend); |
| certitudeObservation = new ColumnConfig(Msg.get("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(Msg.get("phenologie"), "phenologie", 40, true, colRend); |
| ordreObservation = new ColumnConfig(Msg.get("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; |
| Timer t = new Timer() { |
| |
| @Override |
| public void run() { |
| enregistrerEtatTri(); |
| observationMediateur.obtenirListeObservation(); |
| } |
| }; |
| t.schedule(200); |
| } |
| }); |
| |
| 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("xls", "standard"); |
| } |
| }); |
| |
| ExtElement lienExportFull = Ext.get("lienExportFull") ; |
| lienExportFull.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| observationMediateur.exporterObservations("xls", "standard,avance,etendu,baseflor"); |
| } |
| }); |
| |
| 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(Msg.get("glissez-observations-pour-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(Msg.get("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\"> "+Msg.get("filtres")+" - "+texteFiltresEnCours+"</span>"; |
| } |
| |
| this.setTitle(Msg.get("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 = Msg.get("departement"); |
| } else if(nomFiltre.equals("localite")) { |
| nomFiltre = Msg.get("localite"); |
| } else if(nomFiltre.equals("nom_taxon")) { |
| nomFiltre = Msg.get("recherche"); |
| } else if(nomFiltre.equals("id_mots_cles")) { |
| nomFiltre = Msg.get("projets"); |
| } else if(nomFiltre.equals("lieudit")) { |
| nomFiltre = Msg.get("lieu-dit"); |
| } else { |
| nomFiltre = Msg.get(nomFiltre); |
| } |
| |
| 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", Msg.get("inconnue")); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("null", Msg.get("inconnue")); |
| valeurFiltreTransformee = valeurFiltreTransformee.replaceAll("NULL", Msg.get("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; |
| } |
| |
| public String renvoyerTri() { |
| String tri = "ordre"; |
| if(triActif) { |
| HashMap<String, String> corr = Ontologies.getCorrespondanceGrilleObservationChampsTri(); |
| if(corr.containsKey(champTri)) { |
| tri = corr.get(champTri); |
| } |
| } |
| return tri; |
| } |
| |
| public String renvoyerDirectionTri() { |
| try { |
| return (triActif) ? directionTri.getDirection() : "ASC"; |
| } catch (Exception e) { |
| return "ASC"; |
| } |
| } |
| } |
| Property changes: |
|---|
| Added: svn:mergeinfo |
|---|
| Added: svn:executable |
|---|
| +* |
|---|
| \ No newline at end of property |
|---|