| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/FormulaireSaisieObservationVue.java |
|---|
| New file |
| 0,0 → 1,2373 |
| package org.tela_botanica.client.vues.observation; |
| // TODO Detecter redim et supprimer ajuster |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.tela_botanica.client.CarnetEnLigneMediateur; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielLocaliteAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO; |
| import org.tela_botanica.client.modeles.objets.ChampEtendu; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| 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.modeles.objets.ReferentielLocalite; |
| import org.tela_botanica.client.modeles.objets.ReferentielNom; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.ChampSaisieEtendu; |
| import org.tela_botanica.client.util.FormulaireSaisieChampEtendu; |
| import org.tela_botanica.client.util.Util; |
| import org.tela_botanica.client.util.autocompletion.AutoCompletionComboBox; |
| import com.google.gwt.core.client.Callback; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.http.client.Response; |
| import com.google.gwt.user.client.Timer; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.PopupPanel; |
| 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.ListenerConfig; |
| import com.gwtext.client.core.Position; |
| import com.gwtext.client.widgets.BoxComponent; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Container; |
| import com.gwtext.client.widgets.DatePicker; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.event.DatePickerListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.ComboBox; |
| import com.gwtext.client.widgets.form.DateField; |
| import com.gwtext.client.widgets.form.Field; |
| import com.gwtext.client.widgets.form.FormPanel; |
| import com.gwtext.client.widgets.form.Label; |
| import com.gwtext.client.widgets.form.MultiFieldPanel; |
| import com.gwtext.client.widgets.form.TextArea; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
| import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter; |
| import com.gwtext.client.widgets.layout.AnchorLayoutData; |
| import com.gwtext.client.widgets.layout.ColumnLayout; |
| import com.gwtext.client.widgets.layout.ColumnLayoutData; |
| import com.gwtext.client.widgets.layout.FormLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.data.Record; |
| /** |
| * Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il implémente l'interface rafraichissable |
| * @author aurelien |
| * |
| */ |
| public class FormulaireSaisieObservationVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| FormPanel panneauFormulaire = null; |
| private DateField date = null; |
| private AutoCompletionComboBox lieudit = null; |
| private AutoCompletionComboBox station = null; |
| private AutoCompletionComboBox milieu = null; |
| private TextField comment = null; |
| private AutoCompletionComboBox localite = null; |
| private String codeLocalite = null; |
| private String pays = null; |
| private AutoCompletionComboBox espece = null; |
| private Map<String, ReferentielNom> referentielNom = null; |
| private Map<String, ReferentielLocalite> referentielLocalite = null; |
| private String numeroNom = null; |
| private String numeroOrdre = null; |
| private String referentielTaxo = null; |
| private String referentielGeo = null; |
| private Map<String, String> avertissementPresence = new HashMap<String, String>(); |
| private boolean enRequeteChrologie = false; |
| // Pour remise a zero partielle lors d'une validation |
| private enum Champs { |
| DATE, LIEUDIT, STATION, MILIEU, COMMENT, LOCALITE, ESPECE, TOUT, LATITUDE, LONGITUDE, ALTITUDE, ABONDANCE, CERTITUDE, REFERENTIELTAXO, PHENOLOGIE; |
| @Override |
| public String toString() { |
| switch(this) { |
| case DATE: |
| return "date"; |
| case LOCALITE: |
| return "localite"; |
| case LIEUDIT: |
| return "lieu dit"; |
| case STATION: |
| return "station"; |
| case MILIEU: |
| return "milieu"; |
| case COMMENT: |
| return "notes"; |
| case ESPECE: |
| return "espèce"; |
| case LATITUDE: |
| return "latitude"; |
| case LONGITUDE: |
| return "longitude"; |
| case ALTITUDE: |
| return "altitude"; |
| case ABONDANCE: |
| return "abondance"; |
| case CERTITUDE: |
| return "identification"; |
| case REFERENTIELTAXO: |
| return "referentiel"; |
| case PHENOLOGIE: |
| return "phenologie"; |
| case TOUT: |
| return "date, localite, lieu dit, station, milieu, espèce, notes, latitude, longitude, altitude, abondance, identification, referentiel, phenologie"; |
| } |
| return TOUT.toString(); |
| } |
| }; |
| private String formatDate = null ; |
| private Button boutonOK = new Button(Msg.get("creer")); |
| private Button boutonModifier = new Button(Msg.get("modifier")); |
| private Button boutonSupprimer = new Button(Msg.get("supprimer")); |
| private Button boutonReinitialiser = new Button(Msg.get("reinitialiser")); |
| private boolean selectionlocalite=false; |
| private boolean selectionEspece=false; |
| private boolean selectionAbondance = false; |
| private boolean selectionCertitude = false; |
| private boolean selectionPhenologie = false; |
| private final String VALEURS_MULTIPLES = "("+Msg.get("valeurs-multiples")+")"; |
| private final String modeleMessageModif = "localite:lieu-dit:station:milieu:latitude:longitude:altitude:date:espece:notes:abondance:identification:referentiel:phenologie"; |
| private boolean localiteModifiee = false; |
| private boolean lieuDitModifie = false; |
| private boolean stationModifiee = false; |
| private boolean milieuModifie = false; |
| private boolean dateModifiee = false; |
| private boolean especeModifiee = false; |
| private boolean commModifie = false; |
| private boolean abondanceModifiee = false; |
| private boolean certitudeModifiee = false; |
| private boolean referentielTaxoModifie = false; |
| private boolean phenologieModifiee = false;; |
| private final int KEY_ALT = 18; |
| private final int KEY_BACKSPACE = 8; |
| private final int KEY_CTRL = 17; |
| private final int KEY_DELETE = 46; |
| private final int KEY_DOWN = 40; |
| private final int KEY_END = 35; |
| private final int KEY_ENTER = 13; |
| private final int KEY_ESCAPE = 27; |
| private final int KEY_HOME = 36; |
| private final int KEY_LEFT = 37; |
| private final int KEY_PAGEDOWN = 34; |
| private final int KEY_PAGEUP = 33; |
| private final int KEY_RIGHT = 39; |
| private final int KEY_SHIFT = 16; |
| private final int KEY_TAB = 9; |
| private final int KEY_UP = 38; |
| /** |
| * Booleen d'instanciation |
| */ |
| boolean estInstancie = false ; |
| private Panel panneauIntermediaire; |
| private Panel panneauPremierColonne; |
| private Panel panneauSecondeColonne; |
| private TextField longitude; |
| private TextField latitude; |
| private TextField altitude; |
| private MultiFieldPanel htmllocalitePanel = null; |
| private MultiFieldPanel coordPanel; |
| private TextField coordonnees; |
| private Label lienSelectionlocalite = null; |
| private HTML afficherFormulaireLatLon; |
| private HTML basculerverscarto; |
| private boolean longlatAjoutee; |
| private boolean latModifiee; |
| private boolean longModifiee; |
| private boolean altModifiee; |
| protected boolean recherchelocaliteEnCours = false; |
| private Timer tCoord; |
| private ComboBox selecteurAbondance = null; |
| private ComboBox selecteurCertitude = null; |
| private ComboBox selecteurReferentielTaxo = null; |
| private ComboBox selecteurStadePheno = null; |
| private boolean selectionMultiple = false; |
| private HTML lienAfficherChampsEtendus = null; |
| private HTML lienAjouterChampsEtendus = null; |
| Panel conteneurChampEtenduGauche = null; |
| Panel conteneurChampEtenduDroite = null; |
| private boolean afficherChampsEtendus = false; |
| private boolean afficherLienAjoutChampsEtendus = false; |
| private boolean premierAffichage = true; |
| private PopupPanel popUpAjoutChampEtendu = new PopupPanel(); |
| private Map<String, ChampSaisieEtendu> listeChampsEtendus; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private FormulaireSaisieObservationVue() |
| { |
| super() ; |
| } |
| /** |
| * Constructeur avec argument |
| * @param im |
| */ |
| public FormulaireSaisieObservationVue(ObservationMediateur obs) |
| { |
| super(Msg.get("saisie")); |
| // on associe le médiateur |
| observationMediateur = obs ; |
| referentielTaxo = obs.getRefTaxSelectionne().getCode(); |
| panneauFormulaire = new FormPanel(Position.RIGHT); |
| panneauFormulaire.setBorder(false); |
| // Panneau intermediaire qui contient deux colonnes de formulaire |
| panneauIntermediaire = new Panel(); |
| if (Window.getClientWidth()> Window.getClientHeight()) { |
| panneauIntermediaire.setLayout(new ColumnLayout()); |
| } |
| else { |
| panneauIntermediaire.setLayout(new RowLayout()); |
| } |
| panneauIntermediaire.setBorder(false); |
| //création du panneau formulaire de gauche auquels on ajoute les champs |
| panneauPremierColonne = new Panel(); |
| panneauPremierColonne.setLayout(new FormLayout()); |
| panneauPremierColonne.setBorder(false); |
| //création du panneau formulaire de droite |
| panneauSecondeColonne = new Panel(); |
| panneauSecondeColonne.setLayout(new FormLayout()); |
| panneauSecondeColonne.setBorder(false); |
| this.setPaddings(5) ; |
| // Accesskey pour debugging |
| localite = new AutoCompletionComboBox(Msg.get("localite"), ListeReferentielLocaliteAsynchroneDAO.getUrlReferentielLocalites()) { |
| @Override |
| protected Map<String, String> parserResultatRequete(Response response) { |
| referentielLocalite = Util.parserRetourReferentielLocaliteIndexeParNom(response); |
| return Util.convertirListeReferentielLocaliteVersMap(referentielLocalite); |
| } |
| @Override |
| public void onSelectionValeur() { |
| localiteModifiee = true; |
| surSelectionLocalite(); |
| verifierPresenceTaxonSaisi(); |
| } |
| @Override |
| protected void onModificationValeur() { |
| localiteModifiee = true; |
| verifierPresenceTaxonSaisi(); |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.LOCALITE); |
| } |
| }; |
| //création du lien "Accès carto" dans le formulaire; |
| basculerverscarto = new HTML(" <a id=\"lien_carto\" title=\""+Msg.get("aide-lien-localiser")+"\" href=\"#\" tabindex=\"2\">"+Msg.get("localiser-zone")+"</a>"); |
| basculerverscarto.addStyleName("lien_actif"); |
| //création info bulle sur le lien "accès carto" |
| ToolTip tip2 = new ToolTip(); |
| tip2.setHtml(Msg.get("aide-lien-localiser")); |
| tip2.applyTo(basculerverscarto.getElement()); |
| //Sur une meme ligne, ajout de plusieurs champs |
| htmllocalitePanel = new MultiFieldPanel(); |
| int largeurlocalite = Window.getClientWidth()/4; |
| htmllocalitePanel.addToRow(localite, largeurlocalite); |
| htmllocalitePanel.addToRow(basculerverscarto, 160); |
| htmllocalitePanel.setBorder(false); |
| htmllocalitePanel.setId("x-localite-panel"); |
| panneauPremierColonne.add(htmllocalitePanel); |
| station = new AutoCompletionComboBox(Msg.get("station"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_STATION)) { |
| @Override |
| protected Map<String, String> parserResultatRequete(Response response) { |
| return Util.parserRetourReferentielPerso(response); |
| } |
| @Override |
| public void onSelectionValeur() { |
| stationModifiee = true; |
| } |
| @Override |
| protected void onModificationValeur() { |
| stationModifiee = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.STATION); |
| } |
| @Override |
| protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
| return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur); |
| } |
| }; |
| panneauPremierColonne.add(station, new AnchorLayoutData("95%")); |
| latitude = new TextField(Msg.get("lat"), "lat"); |
| latitude.setGrowMax(70); |
| latitude.setAllowBlank(true); |
| longitude = new TextField(Msg.get("lon"), "lon"); |
| longitude.setGrowMax(70); |
| longitude.setAllowBlank(true); |
| altitude = new TextField(Msg.get("alt"), "alt"); |
| altitude.setGrowMax(70); |
| altitude.setAllowBlank(true); |
| lienSelectionlocalite = new Label(""); |
| lienSelectionlocalite.setId("conteneur_selection_localite"); |
| lienSelectionlocalite.setStyleName("conteneur_selection_localite"); |
| lienSelectionlocalite.addStyleName("lien_actif"); |
| // Panneau de type plusieurs champs de formulaire sur une meme ligne, où seront renseignés Lat/Lon |
| coordPanel = new MultiFieldPanel(); |
| coordPanel.setPaddings(0, 0, 0, 10); |
| coordPanel.setVisible(false); |
| final double largeur ; |
| largeur = 120; |
| coordPanel.addToRow(latitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(longitude, new ColumnLayoutData(largeur)); |
| coordPanel.addToRow(lienSelectionlocalite, new ColumnLayoutData(largeur)); |
| lienSelectionlocalite.addClass("lien_decale"); |
| coordPanel.setBorder(false); |
| coordPanel.addToRow(altitude, new ColumnLayoutData(largeur)); |
| //création du champs coordonnées |
| referentielGeo = Configuration.getReferentielGeo(); |
| coordonnees = new TextField(Msg.get("coordonnees"), "", 0); |
| coordonnees.setMaxLength(0); |
| coordonnees.setReadOnly(true); |
| coordonnees.setCls("fieldname"); |
| //création du lien "saisie X/Y" dans le formulaire |
| afficherFormulaireLatLon = new HTML("<span style=\"padding-left:30px;\" class=\"conteneur_lien_afficher_lat_lon\">" + |
| "<a title=\""+Msg.get("indication-formulaire-lat-lon")+"\" class=\"lien_actif\" id=\"lien_coord\" href=\"#\" tabindex=\"6\">"+Msg.get("saisie-lat-lon")+" ("+referentielGeo+")</a>" + |
| "<span><span style=\"padding-left:20px\" class=\"conteneur_lien_localiser_lat_lon\">"+ |
| "<a title=\""+Msg.get("indication-formulaire-localiser")+"\" class=\"lien_actif\" id=\"lien_carto_coord\" href=\"#\" tabindex=\"7\">"+Msg.get("localiser-la-carte")+"</a>"+ |
| "</span>"); |
| //ajout d'un listener sur le lien "saisie X/Y" |
| coordPanel.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| surPremierAffichageCoordPanel(largeur); |
| } |
| }); |
| //Sur une meme ligne, ajout de plusieurs champs |
| final MultiFieldPanel htmlPanel = new MultiFieldPanel(); |
| htmlPanel.addToRow(coordonnees, 100); |
| htmlPanel.addToRow(afficherFormulaireLatLon, new ColumnLayoutData(0.9)); |
| htmlPanel.setBorder(false); |
| htmlPanel.setId("x-coord-panel"); |
| panneauPremierColonne.add(htmlPanel); |
| panneauPremierColonne.add(coordPanel); |
| date = new DateField(Msg.get("date"), "date", 250); |
| date.setAllowBlank(true); |
| formatDate = "d/m/Y"; |
| date.setFormat(formatDate); |
| date.setTitle(Msg.get("indication-format-date")); |
| date.setMaxValue(new Date()); |
| //date.setTabIndex(5); |
| panneauPremierColonne.add(date, new AnchorLayoutData("55%")); |
| final String champsListeTpl = "<div class=\"x-combo-list-item search-item-tpl\" title=\"{label}\">{label}</div>"; |
| // Selection d'un référentiel par défaut (le premier spécifié dans la config) |
| referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode(); |
| selecteurReferentielTaxo = new ComboBox(); |
| selecteurReferentielTaxo.setCls("champ-separation"); |
| selecteurReferentielTaxo.setLabel(Msg.get("referentiel")); |
| selecteurReferentielTaxo.setStore(Ontologies.getValeursReferentiel()); |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| selecteurReferentielTaxo.setDisplayField("label") ; |
| selecteurReferentielTaxo.setValueField("valeur"); |
| selecteurReferentielTaxo.setEditable(false); |
| selecteurReferentielTaxo.setHideTrigger(false); |
| selecteurReferentielTaxo.setForceSelection(true); |
| selecteurReferentielTaxo.setTpl(champsListeTpl); |
| espece = new AutoCompletionComboBox(Msg.get("espece"), ListeReferentielNomAsynchroneDAO.getBaseUrlReferentielNom()) { |
| @Override |
| protected Map<String, String> parserResultatRequete(Response response) { |
| // TODO: bien penser à l'unicité des clés, ici on suppose que |
| // genre espèce auteur suffit mais quelquefois on peut avoir des doublons |
| referentielNom = Util.parserRetourReferentielNomIndexeParNom(response); |
| return Util.convertirListeReferentielNomVersMap(referentielNom); |
| } |
| @Override |
| public void onSelectionValeur() { |
| especeModifiee = true; |
| surSelectionEspece(); |
| verifierPresenceTaxonSaisi(); |
| } |
| @Override |
| protected void onModificationValeur() { |
| especeModifiee = true; |
| // Pour éviter qu'un mauvais nn ne soit gardé lors d'une modification |
| // vers un nom ne faisant pas partie du référentiel |
| numeroNom = null; |
| if(referentielNom.containsKey(espece.getText())) { |
| numeroNom = referentielNom.get(espece.getText()).getNumeroNom(); |
| } |
| verifierPresenceTaxonSaisi(); |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.ESPECE); |
| } |
| @Override |
| protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
| return ListeReferentielNomAsynchroneDAO.formaterUrlAutoCompletionReferentielNom(urlRequete, referentielTaxo, valeur); |
| } |
| @Override |
| protected String preTraiterValeurAvantAffichage(String valeur) { |
| ReferentielNom nomValeur = referentielNom.get(valeur); |
| String valeurAffichee = nomValeur.getNom(); |
| // Pour afficher les noms retenus en gras |
| if (nomValeur.estRetenu()) { |
| valeurAffichee = "<span class=\"nomRetenu\">"+nomValeur.getNom().trim()+"</span>"; |
| } |
| return valeurAffichee; |
| } |
| }; |
| Panel panelSeparationPp = new Panel(); |
| panelSeparationPp.setHeight(15); |
| panelSeparationPp.setBorder(false); |
| panneauPremierColonne.add(panelSeparationPp); |
| panneauPremierColonne.add(selecteurReferentielTaxo, new AnchorLayoutData("85%")); |
| panneauPremierColonne.add(espece, new AnchorLayoutData("95%")); |
| selecteurAbondance = new ComboBox(); |
| selecteurAbondance.setCls("champ-separation"); |
| selecteurAbondance.setLabel(Msg.get("abondance")); |
| selecteurAbondance.setStore(Ontologies.getValeursAbondance()); |
| selecteurAbondance.setDisplayField("label") ; |
| selecteurAbondance.setValueField("valeur"); |
| selecteurAbondance.setEditable(true); |
| selecteurAbondance.setHideTrigger(false); |
| selecteurAbondance.setForceSelection(false); |
| selecteurAbondance.setTpl(champsListeTpl); |
| panneauPremierColonne.add(selecteurAbondance, new AnchorLayoutData("95%")); |
| lieudit = new AutoCompletionComboBox(Msg.get("lieu-dit"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_LIEU_DIT)) { |
| @Override |
| protected Map<String, String> parserResultatRequete(Response response) { |
| return Util.parserRetourReferentielPerso(response); |
| } |
| @Override |
| public void onSelectionValeur() { |
| lieuDitModifie = true; |
| } |
| @Override |
| protected void onModificationValeur() { |
| lieuDitModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.LIEUDIT); |
| } |
| @Override |
| protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
| return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur); |
| } |
| }; |
| panneauSecondeColonne.add(lieudit, new AnchorLayoutData("95%")); |
| milieu = new AutoCompletionComboBox(Msg.get("milieu"), ListeReferentielPersoAsynchroneDAO.getUrlReferentielPerso(TypesReferentiels.REFERENTIEL_MILIEU)) { |
| @Override |
| protected Map<String, String> parserResultatRequete(Response response) { |
| return Util.parserRetourReferentielPerso(response); |
| } |
| @Override |
| public void onSelectionValeur() { |
| milieuModifie = true; |
| } |
| @Override |
| protected void onModificationValeur() { |
| milieuModifie = true; |
| } |
| @Override |
| public void onValidationSaisie() { |
| validerSaisie(Champs.MILIEU); |
| } |
| @Override |
| protected String preTraiterUrlRequete(String urlRequete, String valeur) { |
| return ListeReferentielPersoAsynchroneDAO.formaterUrlRequeteAutoCompletionPerso(urlRequete, valeur); |
| } |
| }; |
| panneauSecondeColonne.add(milieu, new AnchorLayoutData("95%")); |
| comment = new TextArea(Msg.get("notes"), "comment"); |
| comment.setAllowBlank(true); |
| comment.setHeight(50); |
| panneauSecondeColonne.add(comment, new AnchorLayoutData("95%") ); |
| Panel panelSeparationPs = new Panel(); |
| panelSeparationPs.setHeight(39); |
| panelSeparationPs.setBorder(false); |
| panneauSecondeColonne.add(panelSeparationPs); |
| selecteurCertitude = new ComboBox(); |
| selecteurCertitude.setLabel(Msg.get("identification")); |
| selecteurCertitude.setStore(Ontologies.getValeursCertitude()); |
| selecteurCertitude.setDisplayField("label") ; |
| selecteurCertitude.setValueField("valeur"); |
| selecteurCertitude.setEditable(true); |
| selecteurCertitude.setHideTrigger(false); |
| selecteurCertitude.setForceSelection(false); |
| selecteurCertitude.setTpl(champsListeTpl); |
| panneauSecondeColonne.add(selecteurCertitude, new AnchorLayoutData("95%")); |
| selecteurStadePheno = new ComboBox(); |
| selecteurStadePheno.setLabel(Msg.get("phenologie")); |
| selecteurStadePheno.setStore(Ontologies.getValeursPhenologie()); |
| selecteurStadePheno.setDisplayField("label") ; |
| selecteurStadePheno.setValueField("valeur"); |
| selecteurStadePheno.setEditable(true); |
| selecteurStadePheno.setHideTrigger(false); |
| selecteurStadePheno.setForceSelection(false); |
| selecteurStadePheno.setTpl(champsListeTpl); |
| panneauSecondeColonne.add(selecteurStadePheno, new AnchorLayoutData("95%")); |
| if (Window.getClientWidth() > Window.getClientHeight() || Window.getClientWidth() < 800) { |
| panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5)); |
| panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5)); |
| } |
| else { |
| panneauIntermediaire.add(panneauPremierColonne); |
| panneauIntermediaire.add(panneauSecondeColonne); |
| } |
| panneauFormulaire.add(panneauIntermediaire); |
| if (Ext.isIE()) { |
| panneauPremierColonne.setButtonAlign(Position.RIGHT); |
| panneauPremierColonne.addButton(boutonOK); |
| panneauPremierColonne.addButton(boutonModifier); |
| panneauPremierColonne.addButton(boutonSupprimer); |
| panneauSecondeColonne.setButtonAlign(Position.LEFT); |
| panneauPremierColonne.addButton(boutonReinitialiser); |
| } |
| else { |
| panneauFormulaire.addButton(boutonOK); |
| panneauFormulaire.addButton(boutonModifier); |
| panneauFormulaire.addButton(boutonSupprimer); |
| panneauFormulaire.addButton(boutonReinitialiser); |
| } |
| this.add(panneauFormulaire) ; |
| this.setAutoScroll(true); |
| panneauFormulaire.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onResize(BoxComponent component, int adjWidth, int adjHeight, int rawWidth, int rawHeight) { |
| panneauIntermediaire.setWidth(rawWidth); |
| panneauIntermediaire.setHeight(rawHeight); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| htmllocalitePanel.doLayout(); |
| htmlPanel.doLayout(); |
| redimensionnerChampsEtendus(); |
| doLayout(); |
| } |
| }); |
| lienAfficherChampsEtendus = new HTML(Msg.get("afficher-champs-etendus")); |
| lienAfficherChampsEtendus.setStyleName("img-curseur-depl"); |
| lienAfficherChampsEtendus.setStyleName("lienAfficherChampsEtendus"); |
| lienAfficherChampsEtendus.setVisible(false); |
| lienAfficherChampsEtendus.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(afficherChampsEtendus) { |
| afficherChampsEtendus = false; |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.hide(); |
| conteneurChampEtenduDroite.hide(); |
| } |
| lienAfficherChampsEtendus.setText(Msg.get("afficher-champs-etendus")); |
| } else { |
| afficherChampsEtendus = true; |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.show(); |
| conteneurChampEtenduDroite.show(); |
| redimensionnerChampsEtendus(); |
| } |
| lienAfficherChampsEtendus.setText(Msg.get("cacher-champs-etendus")); |
| } |
| } |
| }); |
| if(Configuration.saisieChampsEtendusActivee()) { |
| // Chargement du cache des correspondances cles/labels du catalogue |
| ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null); |
| lrceDao.obtenirGroupesChampsEtendus(this); |
| lrceDao.obtenirCatalogueChampsEtendus(this); |
| lienAjouterChampsEtendus = new HTML(Msg.get("ajouter-champ-etendu")); |
| lienAjouterChampsEtendus.addStyleName("lienAjouterChampEtendu"); |
| lienAjouterChampsEtendus.setVisible(true); |
| panneauPremierColonne.add(lienAjouterChampsEtendus); |
| gererLienAjoutChampsEtendus(); |
| } |
| panneauPremierColonne.add(lienAfficherChampsEtendus); |
| panneauPremierColonne.addListener(new PanelListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| if(premierAffichage) { |
| lienAfficherChampsEtendus.setVisible(false); |
| premierAffichage = false; |
| } |
| } |
| }); |
| ajouterListeners() ; |
| ajouterToolTipsBoutons(); |
| saisieTabindex(); |
| } |
| protected void surSelectionEspece() { |
| ReferentielNom nom = referentielNom.get(espece.getText()); |
| numeroNom = nom.getNumeroNom(); |
| selectionEspece = true; |
| observationMediateur.obtenirImageInformationExternes(referentielTaxo, numeroNom); |
| } |
| protected void surSelectionLocalite() { |
| ReferentielLocalite infosLoc = referentielLocalite.get(localite.getText()); |
| codeLocalite = infosLoc.getCodeLocalite(); |
| selectionlocalite=true; |
| } |
| private void gererLienAjoutChampsEtendus() { |
| popUpAjoutChampEtendu.setStylePrimaryName("popup_champ_etendu"); |
| lienAjouterChampsEtendus.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| FormulaireSaisieChampEtendu formChamp = new FormulaireSaisieChampEtendu() { |
| @Override |
| public void surValidation(ChampSaisieEtendu champ) { |
| ajouterChampEtenduAuFormulaire(champ, true); |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| @Override |
| public void surAjout(ChampSaisieEtendu champ) { |
| ajouterChampEtenduAuFormulaire(champ, false); |
| } |
| @Override |
| public void surAnnulation() { |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| @Override |
| public void surAjoutMultiple(List<ChampSaisieEtendu> champs) { |
| for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) { |
| ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next(); |
| ajouterChampEtenduAuFormulaire(champSaisieEtendu, false); |
| } |
| } |
| @Override |
| public void surValidationMultiple(List<ChampSaisieEtendu> champs) { |
| for (Iterator<ChampSaisieEtendu> iterator = champs.iterator(); iterator.hasNext();) { |
| ChampSaisieEtendu champSaisieEtendu = (ChampSaisieEtendu) iterator.next(); |
| ajouterChampEtenduAuFormulaire(champSaisieEtendu, false); |
| } |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } |
| }; |
| popUpAjoutChampEtendu.add(formChamp); |
| popUpAjoutChampEtendu.center(); |
| popUpAjoutChampEtendu.setModal(true); |
| popUpAjoutChampEtendu.show(); |
| formChamp.redimensionner(popUpAjoutChampEtendu.getOffsetWidth() - 13); |
| } |
| }); |
| } |
| private void ajouterChampEtenduAuFormulaire(ChampSaisieEtendu nChamp, boolean fermerPopup) { |
| ChampEtendu chet = new ChampEtendu(nChamp.getCle(), nChamp.getLabel(), ""); |
| Map<String, ChampEtendu> champsEt = getValeursChampsEtendus(); |
| if(!champsEt.containsKey(chet.getCle())) { |
| champsEt.put(chet.getCle(), chet); |
| afficherChampsEtendus = true; |
| if(fermerPopup) { |
| afficherChampsEtendus(champsEt, chet); |
| popUpAjoutChampEtendu.clear(); |
| popUpAjoutChampEtendu.hide(); |
| } else { |
| afficherChampsEtendus(champsEt, null); |
| } |
| } else { |
| String[] stParams = {chet.getLabel()}; |
| Window.alert(Msg.get("indication-champ-etendu-existe-deja", stParams)); |
| } |
| } |
| private void ajouterToolTipsBoutons() { |
| boutonOK.setTitle(Msg.get("indication-bouton-creer-obs")); |
| boutonModifier.setTitle(Msg.get("indication-bouton-modifier-obs")); |
| boutonSupprimer.setTitle(Msg.get("indication-bouton-supprimer-obs")); |
| boutonReinitialiser.setTitle(Msg.get("indication-bouton-reinitialiser-obs")); |
| } |
| private void surPremierAffichageCoordPanel(final double largeur) { |
| ExtElement lienCoord = Ext.get("lien_coord"); |
| lienCoord.removeAllListeners(); |
| lienCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| coordPanel.setVisible(!coordPanel.isVisible()); |
| if(Ext.isIE()) { |
| latitude.focus(); |
| } |
| CarnetEnLigneMediateur.fireResize(); |
| } |
| }) ; |
| ExtElement lienCartoCoord = Ext.get("lien_carto_coord"); |
| lienCartoCoord.removeAllListeners(); |
| lienCartoCoord.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| obtenirInformationCoord(); |
| } |
| }) ; |
| ExtElement lienCarto = Ext.get("lien_carto"); |
| lienCarto.removeAllListeners(); |
| lienCarto.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(localite.getText() != null && !localite.getText().equals("")) { |
| obtenirInformationLocalite(); |
| longlatAjoutee = true; |
| } else { |
| Window.alert(Msg.get("indication-localite-vide-invalide")); |
| } |
| } |
| }); |
| if(!Ext.isIE() && Window.getClientWidth() < 1200) { |
| int largeurN = (int)largeur; |
| latitude.setWidth(largeurN+"px"); |
| longitude.setWidth(largeurN+"px"); |
| lienSelectionlocalite.setWidth(largeurN+"px"); |
| } |
| } |
| private void ajouterListeners() |
| { |
| // Listener completion communne |
| final Rafraichissable r = this; |
| ListenerConfig listenerConfiglocalite=new ListenerConfig(); |
| listenerConfiglocalite.setDelay(200); |
| listenerConfiglocalite.setStopPropagation(false); |
| listenerConfiglocalite.setStopEvent(false); |
| date.addListener(new DatePickerListenerAdapter() { |
| @Override |
| public void onSelect(DatePicker dataPicker, Date date) { |
| dateModifiee = true; |
| } |
| }); |
| ListenerConfig listenerConfigAutocompletion=new ListenerConfig(); |
| listenerConfigAutocompletion.setDelay(200); |
| listenerConfigAutocompletion.setStopPropagation(false); |
| listenerConfigAutocompletion.setStopEvent(false); |
| ListenerConfig listenerConfigEspece=new ListenerConfig(); |
| listenerConfigEspece.setDelay(10); |
| listenerConfigEspece.setStopPropagation(false); |
| listenerConfigEspece.setStopEvent(false); |
| tCoord = new Timer() { |
| @Override |
| public void run() { |
| double[] coord = coordonneesValides(); |
| if(!recherchelocaliteEnCours && coord != null && (longModifiee || latModifiee)) { |
| recherchelocaliteEnCours = true; |
| Ext.get(lienSelectionlocalite.getElement()).mask(Msg.get("recherche")); |
| observationMediateur.obtenirInformationCoord(r,coord[0], coord[1]); |
| } |
| } |
| }; |
| ajouterListenerChampEvenementsClavier(date); |
| ajouterListenerChampEvenementsClavier(selecteurReferentielTaxo); |
| ajouterListenerChampEvenementsClavier(comment); |
| ajouterListenerChampEvenementsClavier(latitude); |
| ajouterListenerChampEvenementsClavier(longitude); |
| ajouterListenerChampEvenementsClavier(altitude); |
| ajouterListenerChampEvenementsClavier(selecteurAbondance); |
| ajouterListenerChampEvenementsClavier(selecteurCertitude); |
| ajouterListenerChampEvenementsClavier(selecteurStadePheno); |
| ajouterListenerChampsCombobox(); |
| boutonOK.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| ajouterObservation(); |
| } |
| }); |
| boutonModifier.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(selectionMultiple) { |
| modifierObservationEnMasse(); |
| } else { |
| modifierObservation() ; |
| } |
| } |
| }); |
| boutonSupprimer.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(!selectionMultiple) { |
| supprimerObservation(); |
| } else { |
| observationMediateur.supprimerObservations(); |
| } |
| } |
| }); |
| boutonReinitialiser.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| setSelectionMultiple(false); |
| raz(); |
| } |
| }); |
| this.addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container self) { |
| localite.focus(); |
| } |
| }); |
| } |
| private void ajouterListenerChampsCombobox() { |
| selecteurReferentielTaxo.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| referentielTaxo = record.getAsString("valeur"); |
| observationMediateur.setRefTaxSelectionne(index); |
| referentielTaxoModifie = true; |
| } |
| }); |
| selecteurAbondance.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionAbondance=true; |
| abondanceModifiee = true; |
| } |
| }); |
| selecteurCertitude.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionCertitude=true; |
| certitudeModifiee = true; |
| } |
| }); |
| selecteurStadePheno.addListener(new ComboBoxListenerAdapter() { |
| @Override |
| public void onSelect(ComboBox comboBox, Record record, int index) { |
| selectionPhenologie=true; |
| phenologieModifiee = true; |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }); |
| } |
| private void ajouterListenerChampEvenementsClavier(final TextField champ, final ListenerConfig config) { |
| champ.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| surEvenementClavier(e, champ); |
| } |
| }, config); |
| } |
| private void surEvenementClavier(EventObject e, TextField champ) { |
| switch(e.getKey()) { |
| case KEY_ALT: |
| case KEY_CTRL: |
| case KEY_DOWN: |
| case KEY_END: |
| case KEY_ESCAPE: |
| case KEY_HOME: |
| case KEY_LEFT: |
| case KEY_PAGEDOWN: |
| case KEY_PAGEUP: |
| case KEY_RIGHT: |
| case KEY_SHIFT: |
| case KEY_TAB: |
| case KEY_UP: |
| break; |
| case KEY_ENTER: |
| surEvenementClavierToucheEntree(champ); |
| break; |
| default: |
| gererEvenementClavierDefaut(champ); |
| break; |
| } |
| } |
| private void surEvenementClavierToucheEntree(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| if(!selectionPhenologie) { |
| validerSaisie(Champs.PHENOLOGIE); |
| } else { |
| selectionPhenologie = false; |
| } |
| } |
| if(champ.equals(selecteurCertitude)) { |
| if(!selectionCertitude) { |
| validerSaisie(Champs.CERTITUDE); |
| } else { |
| selectionCertitude = false; |
| } |
| } |
| if(champ.equals(selecteurAbondance)) { |
| if(!selectionAbondance) { |
| validerSaisie(Champs.ABONDANCE); |
| } else { |
| selectionAbondance = false; |
| } |
| } |
| if(champ.equals(longitude)) { |
| validerSaisie(Champs.LONGITUDE); |
| } |
| if(champ.equals(latitude)) { |
| validerSaisie(Champs.LATITUDE); |
| } |
| if(champ.equals(altitude)) { |
| validerSaisie(Champs.ALTITUDE); |
| } |
| if(champ.equals(espece)) { |
| if(selectionEspece) { |
| especeModifiee = true; |
| selectionEspece=false; |
| } |
| else { |
| validerSaisie(Champs.ESPECE); |
| } |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| validerSaisie(Champs.REFERENTIELTAXO); |
| } |
| if(champ.equals(date)) { |
| validerSaisie(Champs.DATE); |
| } |
| if(champ.equals(localite)) { |
| if(champ.equals(localite)) { |
| if (selectionlocalite) { |
| localiteModifiee= true; |
| selectionlocalite=false; |
| } |
| else { |
| validerSaisie(Champs.LOCALITE); |
| } |
| } |
| } |
| } |
| private void gererEvenementClavierDefaut(TextField champ) { |
| //TODO: faire un switch ou une enum |
| if(champ.equals(selecteurStadePheno)) { |
| selecteurStadePheno.setRawValue(selecteurStadePheno.getRawValue()); |
| selecteurStadePheno.setValue(selecteurStadePheno.getRawValue()); |
| phenologieModifiee = true; |
| selectionPhenologie = false; |
| } |
| if(champ.equals(selecteurCertitude)) { |
| selecteurCertitude.setRawValue(selecteurCertitude.getRawValue()); |
| selecteurCertitude.setValue(selecteurCertitude.getRawValue()); |
| certitudeModifiee = true; |
| selectionCertitude = false; |
| } |
| if(champ.equals(selecteurAbondance)) { |
| selecteurAbondance.setRawValue(selecteurAbondance.getRawValue()); |
| selecteurAbondance.setValue(selecteurAbondance.getRawValue()); |
| abondanceModifiee = true; |
| selectionAbondance = false; |
| } |
| if(champ.equals(longitude)) { |
| longModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(latitude)) { |
| latModifiee = true; |
| tCoord.cancel(); |
| tCoord.schedule(250); |
| } |
| if(champ.equals(altitude)) { |
| altModifiee = true; |
| } |
| if(champ.equals(comment)) { |
| commModifie = true; |
| } |
| if(champ.equals(espece)) { |
| numeroNom=""; |
| especeModifiee = true; |
| } |
| if(champ.equals(selecteurReferentielTaxo)) { |
| referentielTaxoModifie = true; |
| } |
| if(champ.equals(date)) { |
| dateModifiee = true; |
| } |
| if(champ.equals(localite)) { |
| codeLocalite=""; |
| localite.collapse(); |
| localiteModifiee= true; |
| } |
| } |
| /** |
| * Validation de la saisie |
| */ |
| private void validerSaisie(Champs champs) { |
| if(!selectionMultiple) { |
| ajouterObservation(); |
| raz(champs); |
| } else { |
| modifierObservationEnMasse(); |
| } |
| } |
| /** |
| * Desactive visuellement ce panneau |
| */ |
| public void desactiverPanneau() |
| { |
| this.setDisabled(true) ; |
| } |
| /** |
| * Active visuellement ce panneau |
| */ |
| public void activerPanneau() |
| { |
| this.setDisabled(false) ; |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| // On recoit une observation dont on veut afficher le detail |
| if(nouvelleDonnees instanceof Observation) |
| { |
| Observation obs = (Observation)nouvelleDonnees ; |
| setSelectionMultiple(false); |
| afficherDetailsObservation(obs) ; |
| } |
| if(nouvelleDonnees instanceof ListeObservation) { |
| ListeObservation listeObs = (ListeObservation)nouvelleDonnees; |
| setSelectionMultiple(true); |
| calculerAfficherDifferences(listeObs); |
| } |
| if(nouvelleDonnees instanceof String) |
| { |
| String str = (String)nouvelleDonnees ; |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| if(nouvelleDonnees instanceof String[]) { |
| String[] anumNom = (String[])nouvelleDonnees ; |
| numeroNom = anumNom[1]; |
| espece.setValue(anumNom[0]); |
| } |
| if(nouvelleDonnees instanceof EntiteGeographiqueObservation) |
| { |
| EntiteGeographiqueObservation infosComm = (EntiteGeographiqueObservation)nouvelleDonnees ; |
| if(recherchelocaliteEnCours) { |
| afficherIndicationlocalite(infosComm); |
| } else { |
| rafraichirlocaliteEtCoord(infosComm); |
| } |
| } |
| } |
| private void afficherIndicationlocalite( |
| final EntiteGeographiqueObservation infosCom) { |
| String nlocalite = ""; |
| if(infosCom != null && infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().trim().isEmpty()) { |
| nlocalite += infosCom.getZoneGeo(); |
| if(infosCom.getIdZoneGeo() != null && !infosCom.getIdZoneGeo().trim().isEmpty()) { |
| if(Util.estUnDepartement(infosCom.getIdZoneGeo())) { |
| nlocalite += " ("+Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo())+")"; |
| } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) { |
| nlocalite += " ("+infosCom.getPays()+")"; |
| } |
| } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) { |
| nlocalite += " ("+infosCom.getPays()+")"; |
| } |
| lienSelectionlocalite.setHtml("<a id=\"lien_selection_localite\" tabindex=\"9\">"+nlocalite+"</a>"); |
| lienSelectionlocalite.setStyleName("img-curseur-depl"); |
| Ext.get("lien_selection_localite").addListener("click",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| rafraichirlocalite(infosCom); |
| } |
| }); |
| Ext.get("lien_selection_localite").addListener("keypress",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| if(e.getCharCode() == KEY_ENTER) { |
| rafraichirlocalite(infosCom); |
| } |
| } |
| }); |
| Ext.get("lien_selection_localite").addListener("focus",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_localite").toggleClass("lien_sel"); |
| } |
| }); |
| Ext.get("lien_selection_localite").addListener("blur",new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| Ext.get("lien_selection_localite").toggleClass("lien_sel"); |
| } |
| }); |
| } else { |
| if(recherchelocaliteEnCours) { |
| lienSelectionlocalite.setHtml("<span id=\"aucune_selection_localite\"> "+Msg.get("erreur-localisation")+" </span>"); |
| } else { |
| lienSelectionlocalite.setHtml("<span id=\"aucune_selection_localite\"> </span>"); |
| } |
| } |
| Ext.get(lienSelectionlocalite.getElement()).unmask(); |
| recherchelocaliteEnCours = false; |
| } |
| private void rafraichirlocalite(EntiteGeographiqueObservation infosCom) { |
| String nlocalite = ""; |
| if(infosCom.getZoneGeo() != null && !infosCom.getZoneGeo().equals("")) { |
| nlocalite += infosCom.getZoneGeo(); |
| } |
| if(infosCom.getIdZoneGeo() != null && Util.estUnDepartement(infosCom.getIdZoneGeo())) { |
| String codeGeoFormate = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| nlocalite += " ("+codeGeoFormate+")"; |
| codeLocalite = Util.convertirChaineZoneGeoVersDepartement(infosCom.getIdZoneGeo()); |
| } else if(infosCom.getPays() != null && !infosCom.getPays().trim().isEmpty()) { |
| nlocalite += " ("+infosCom.getPays()+")"; |
| } |
| if (!nlocalite.isEmpty()) { |
| // Vide ou null, on remplace ! |
| if(localite.getText() == null || localite.getText().trim().isEmpty()) { |
| localite.setValue(nlocalite); |
| } else { |
| // Afin de pas effacer un pays précédemment saisi, si on a déjà saisi une localité |
| // avec le même nom mais avec un pays, on ne remplace rien |
| if(localite.getText() != null && !localite.getText().contains(nlocalite)) { |
| localite.setValue(nlocalite); |
| } |
| } |
| localiteModifiee = true; |
| } |
| } |
| // Se déclenche au retour de la "localisation sur la carte" |
| private void rafraichirlocaliteEtCoord(EntiteGeographiqueObservation infosCom) { |
| rafraichirlocalite(infosCom); |
| if(infosCom.getLat() != null && !infosCom.getLat().equals("")) { |
| latitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLat(), 5)); |
| } |
| if(infosCom.getLon() != null && !infosCom.getLon().equals("")) { |
| longitude.setValue(Util.tronquerNombrePourAffichage("" + infosCom.getLon(), 5)); |
| } |
| latModifiee = true; |
| longModifiee = true; |
| coordPanel.setVisible(true); |
| } |
| public void ajouterObservation() { |
| if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) { |
| Window.alert(Msg.get("indication-date-invalide")); |
| date.setInvalidText(Msg.get("date-invalide")); |
| return; |
| } |
| affecterCodeLocaliteOuPays(); |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,localite.getText(),codeLocalite,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| String[] coords = getValeurCoordonnees(); |
| obs.setPays(pays); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAltitude(altitude.getText()); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(Ontologies.getInfosReferentielNomParCode(referentielTaxo).getCodeVersionComplet()); |
| obs.setChampsEtendus(getValeursChampsEtendus()); |
| observationMediateur.ajouterObservation(obs); |
| } |
| private void modifierObservation() { |
| if(!Window.confirm(Msg.get("question-modifier-observation")+" ?")) { |
| return; |
| } |
| if(date.getRawValue() != null && !date.getRawValue().equals("") && !Util.verifierDateFormatCel(date.getRawValue())) { |
| Window.alert(Msg.get("indication-date-invalide")); |
| date.setInvalidText(Msg.get("date-invalide")); |
| return; |
| } |
| affecterCodeLocaliteOuPays(); |
| String dateObs = Util.remplacerSeparateursDateFormatCel(date.getRawValue()); |
| Observation obs=new Observation(espece.getText(),numeroNom,localite.getText(),codeLocalite,lieudit.getText(),station.getText(),milieu.getText(), comment.getText(),dateObs); |
| obs.setNumeroOrdre(numeroOrdre); |
| String[] coords = getValeurCoordonnees(); |
| obs.setPays(pays); |
| obs.setLatitude(coords[0]); |
| obs.setLongitude(coords[1]); |
| obs.setAltitude(altitude.getText()); |
| obs.setAbondance(getAbondance()); |
| obs.setCertitude(getCertitude()); |
| obs.setPhenologie(getPhenologie()); |
| obs.setReferentielTaxo(getReferentielTaxo()); |
| obs.setChampsEtendus(getValeursChampsEtendus()); |
| observationMediateur.modifierObservation(obs); |
| } |
| private void affecterCodeLocaliteOuPays() { |
| codeLocalite = ""; |
| pays = ""; |
| // Soit un numéro de département, soit un code de pays à deux lettres |
| String[] codeCom = localite.getText().split(" "); |
| if(codeCom.length > 1 && ressembleAUnCodePaysOuDepartement(codeCom[codeCom.length - 1])) { |
| String codeLoc = codeCom[codeCom.length - 1].replace('(', ' '); |
| codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim(); |
| if(Util.estUnDepartement(codeLoc)) { |
| codeLocalite = codeLoc ; |
| } else { |
| pays = codeLoc.toUpperCase(); |
| } |
| } |
| } |
| private boolean ressembleAUnCodePaysOuDepartement(String s) { |
| String sP = s.replace("(", "").replace(")", "").trim(); |
| boolean contientDesParentheses = s.contains("(") && s.contains(")"); |
| boolean estUnCodePays = !Util.estUnNombre(sP) && (sP.length() == 2); |
| boolean estUnCodeDepartement = Util.estUnNombre(sP) && (sP.length() >= 1 && sP.length() <= 5); |
| return contientDesParentheses && (estUnCodePays || estUnCodeDepartement); |
| } |
| private void modifierObservationEnMasse() { |
| //TODO: factoriser |
| String paysM = null; |
| String localiteM = null; |
| String codeLocaliteM = null; |
| String numNomSelM = null; |
| String lieuDitM = null; |
| String stationM = null; |
| String milieuM = null; |
| String dateM = null; |
| String especeM = null; |
| String commM = null; |
| String latM = null; |
| String longM = null; |
| String altM = null; |
| String abondanceM = null; |
| String certitudeM = null; |
| String referentielTaxoM = null; |
| String phenologieM = null; |
| String champs = modeleMessageModif; |
| if(localiteModifiee && ! localite.getRawValue().equals(VALEURS_MULTIPLES)) { |
| localiteM = localite.getText(); |
| // Soit un numéro de département, soit un code de pays à deux lettres |
| String[] codeCom = localite.getText().split(" "); |
| if(codeCom.length > 1) { |
| String codeLoc = codeCom[1].replace('(', ' '); |
| codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim(); |
| if(Util.estUnDepartement(codeLoc)) { |
| codeLocaliteM = codeLoc ; |
| } else { |
| paysM = codeLoc; |
| } |
| } |
| } |
| else { |
| champs = champs.replaceAll("localite", ""); |
| } |
| if(lieuDitModifie && ! lieudit.getRawValue().equals(VALEURS_MULTIPLES)) { |
| lieuDitM = lieudit.getText(); |
| } else { |
| champs = champs.replaceAll(":lieu-dit", ""); |
| } |
| if(stationModifiee && ! station.getRawValue().equals(VALEURS_MULTIPLES)) { |
| stationM = station.getText(); |
| } else { |
| champs = champs.replaceAll(":station", ""); |
| } |
| if(milieuModifie && ! milieu.getRawValue().equals(VALEURS_MULTIPLES)) { |
| milieuM = milieu.getText(); |
| } else { |
| champs = champs.replaceAll(":milieu", ""); |
| } |
| if(dateModifiee && ! date.getRawValue().equals(VALEURS_MULTIPLES)) { |
| dateM = date.getRawValue(); |
| dateM = Util.remplacerSeparateursDateFormatCel(dateM); |
| } else { |
| champs = champs.replaceAll(":date", ""); |
| } |
| if(especeModifiee && ! espece.getRawValue().equals(VALEURS_MULTIPLES)) { |
| especeM = espece.getText(); |
| numNomSelM = numeroNom; |
| } else { |
| champs = champs.replaceAll(":espece", ""); |
| } |
| if(commModifie && ! comment.getRawValue().equals(VALEURS_MULTIPLES)) { |
| commM = comment.getText(); |
| } else { |
| champs = champs.replaceAll(":notes", ""); |
| } |
| if(latModifiee && ! latitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| latM = latitude.getText(); |
| } else { |
| champs = champs.replaceAll(":latitude", ""); |
| } |
| if(altModifiee && ! altitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| altM = altitude.getText(); |
| } else { |
| champs = champs.replaceAll(":altitude", ""); |
| } |
| if(longModifiee && ! longitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| longM = longitude.getText(); |
| } else { |
| champs = champs.replaceAll(":longitude", ""); |
| } |
| if(abondanceModifiee && !selecteurAbondance.getRawValue().equals(VALEURS_MULTIPLES)) { |
| abondanceM = getAbondance(); |
| } else { |
| champs = champs.replaceAll(":abondance", ""); |
| } |
| if(certitudeModifiee && !selecteurCertitude.getRawValue().equals(VALEURS_MULTIPLES)) { |
| certitudeM = getCertitude(); |
| } else { |
| champs = champs.replaceAll(":identification", ""); |
| } |
| if(referentielTaxoModifie && !selecteurReferentielTaxo.getRawValue().equals(VALEURS_MULTIPLES)) { |
| referentielTaxoM = getReferentielTaxo(); |
| } else { |
| champs = champs.replaceAll(":referentiel", ""); |
| } |
| if(phenologieModifiee && !selecteurStadePheno.getRawValue().equals(VALEURS_MULTIPLES)) { |
| phenologieM = getPhenologie(); |
| } else { |
| champs = champs.replaceAll(":phenologie", ""); |
| } |
| // TODO : trouver un meilleur système que ça pour gérer le message |
| // affiché |
| String[] champsSt = champs.split(":"); |
| String champsTraduits = ""; |
| for (int i = 0; i < champsSt.length; i++) { |
| // TODO: vérifier pourquoi des fois la chaîne est vide |
| // ou faire mieux, trouver un meilleur système comme écrit au dessus ! |
| if(!champsSt[i].trim().isEmpty()) { |
| champsTraduits += Msg.get(champsSt[i]); |
| champsTraduits += (i != champsSt.length - 1) ? ", " : ""; |
| } |
| } |
| String[] stParams = {champsTraduits}; |
| String message = Msg.get("question-modifier-champs-observation", stParams)+" ?" ; |
| if(champs.trim().equals("")) { |
| Window.alert(Msg.get("indication-aucun-champ-modifie")); |
| } else { |
| Observation obs = new Observation(especeM,numNomSelM,localiteM,codeLocaliteM,lieuDitM,stationM,milieuM, commM,dateM); |
| obs.setPays(paysM); |
| obs.setNumeroOrdre(numeroOrdre); |
| obs.setLatitude(latM); |
| obs.setLongitude(longM); |
| obs.setAltitude(altM); |
| obs.setAbondance(abondanceM); |
| obs.setCertitude(certitudeM); |
| // Afin de transmettre un ensemble cohérent on force aussi |
| // l'envoi du référentiel en cas de maj de l'espèce |
| if(especeModifiee) { |
| referentielTaxoM = getReferentielTaxo(); |
| } |
| obs.setReferentielTaxo(referentielTaxoM); |
| obs.setPhenologie(phenologieM); |
| if(Window.confirm(message)) { |
| observationMediateur.modifierObservationEnMasse(obs); |
| reinitialiserValeurModifiees(); |
| } |
| } |
| } |
| private void supprimerObservation() { |
| observationMediateur.supprimerObservation(this, numeroOrdre); |
| } |
| public void afficherDetailsObservation(Observation obs) |
| { |
| raz() ; |
| String idLoc ; |
| if(obs.getIdentifiantLocalite() != VALEURS_MULTIPLES) { |
| idLoc = obs.getIdentifiantLocalite().replaceAll(" ","/"); |
| idLoc = idLoc.replaceAll("%",""); |
| idLoc = idLoc.replaceAll("\"",""); |
| idLoc = idLoc.replace('\\',' '); |
| idLoc = idLoc.trim(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } else { |
| idLoc = obs.getIdentifiantLocalite(); |
| if(idLoc.length() == 5) { |
| idLoc = idLoc.substring(0,2); |
| } |
| } |
| if(obs.getIdentifiantLocalite().isEmpty() && !obs.getPays().isEmpty()) { |
| idLoc = obs.getPays(); |
| } |
| if(!obs.getDate().equals("null") && !obs.getDate().equals("000null") && !obs.getDate().equals(VALEURS_MULTIPLES)) { |
| String[] dateEtHeure = obs.getDate().split(" ", 2); |
| if(verifierFormatDate(dateEtHeure[0])) { |
| date.setValue(dateEtHeure[0]) ; |
| } |
| else |
| { |
| date.setRawValue(""); |
| } |
| } else { |
| date.setRawValue(VALEURS_MULTIPLES); |
| date.clearInvalid(); |
| } |
| if(!obs.getLieudit().equals("null") && !obs.getLieudit().equals("000null")) { |
| lieudit.setValue(obs.getLieudit()) ; |
| } |
| if(!obs.getStation().equals("null") && !obs.getStation().equals("000null")) { |
| station.setValue(obs.getStation()) ; |
| } |
| if(!obs.getMilieu().equals("null") && !obs.getMilieu().equals("000null")) { |
| milieu.setValue(obs.getMilieu()) ; |
| } |
| if(!obs.getCommentaire().equals("null") && !obs.getCommentaire().equals("000null")) { |
| comment.setRawValue(Util.remplacerSautsDeligneMalEncodes(obs.getCommentaire())); |
| } |
| if(!obs.getLocalite().equals("null") && !obs.getLocalite().equals("000null")) { |
| if(!idLoc.equals("000null") && !idLoc.equals("")) { |
| if(!idLoc.equals(VALEURS_MULTIPLES)) { |
| localite.setValue(obs.getLocalite()+" ("+idLoc+")") ; |
| } else { |
| localite.setValue(VALEURS_MULTIPLES); |
| } |
| } |
| else |
| { |
| localite.setValue(obs.getLocalite()); |
| } |
| } |
| if(!obs.getIdentifiantLocalite().equals("null") && !obs.getIdentifiantLocalite().equals("000null")) { |
| codeLocalite = idLoc; |
| } |
| if(!obs.getNomSaisi().equals("null") && !obs.getNomSaisi().equals("000null")) { |
| espece.setValue(obs.getNomSaisi()) ; |
| } |
| if(!obs.getNumeroNomenclaturalSaisi().equals("null") && !obs.getNumeroNomenclaturalSaisi().equals("000null")) { |
| numeroNom = obs.getNumeroNomenclaturalSaisi() ; |
| } |
| if(!obs.getNumeroOrdre().equals("null") && !obs.getNumeroOrdre().equals("000null")) { |
| numeroOrdre = obs.getNumeroOrdre() ; |
| } |
| if(doitAfficherLatLon(obs)) { |
| latitude.setValue(Util.formaterNombre(obs.getLatitude())) ; |
| longitude.setValue(Util.formaterNombre(obs.getLongitude())) ; |
| } |
| if(!obs.getAltitude().isEmpty() && !obs.getAltitude().equals("null") && !obs.getAltitude().equals("000null")) { |
| altitude.setValue(Util.formaterNombre(obs.getAltitude())) ; |
| } |
| selecteurAbondance.getStore().load(); |
| selecteurAbondance.setValue(obs.getAbondance()); |
| selecteurCertitude.getStore().load(); |
| selecteurCertitude.setValue(obs.getCertitude()); |
| selecteurStadePheno.getStore().load(); |
| selecteurStadePheno.setValue(obs.getPhenologie()); |
| selecteurReferentielTaxo.getStore().load(); |
| if(obs.getReferentielTaxo() != VALEURS_MULTIPLES) { |
| referentielTaxo = obs.getCodeCourtReferentielTaxo(); |
| if(referentielTaxo == null || referentielTaxo.isEmpty()) { |
| referentielTaxo = Configuration.getReferentielsDispos().get(0).getCode(); |
| } |
| selecteurReferentielTaxo.setValue(referentielTaxo); |
| } else { |
| referentielTaxo = ""; |
| selecteurReferentielTaxo.setRawValue(VALEURS_MULTIPLES); |
| } |
| afficherChampsEtendus(obs.getChampsEtendus(), null); |
| } |
| private boolean doitAfficherLatLon(Observation obs) { |
| return !obs.getLatitude().isEmpty() && |
| !obs.getLatitude().equals("null") && |
| !obs.getLatitude().equals("000null") && |
| !Util.estZero(obs.getLatitude()) && |
| !obs.getLongitude().isEmpty() && |
| !obs.getLongitude().equals("null") && |
| !obs.getLongitude().equals("000null") && |
| !Util.estZero(obs.getLongitude()); |
| } |
| private void viderChampsEtendus() { |
| if(listeChampsEtendus != null) { |
| for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) { |
| ChampSaisieEtendu champEtendu = listeChampsEtendus.get(it.next()); |
| champEtendu.destroy(); |
| } |
| if(conteneurChampEtenduGauche != null && conteneurChampEtenduDroite != null) { |
| conteneurChampEtenduGauche.clear(); |
| conteneurChampEtenduDroite.clear(); |
| panneauPremierColonne.remove(conteneurChampEtenduGauche); |
| panneauSecondeColonne.remove(conteneurChampEtenduDroite); |
| } |
| listeChampsEtendus = null; |
| } |
| } |
| private void afficherChampsEtendus(Map<String, ChampEtendu> champsEtendus, ChampEtendu champsAFocus) { |
| champsEtendus = Util.trierListeChampsEtendus(champsEtendus); |
| viderChampsEtendus(); |
| FormLayout flmd = new FormLayout(); |
| flmd.setLabelWidth(150); |
| FormLayout flmg = new FormLayout(); |
| flmg.setLabelWidth(150); |
| conteneurChampEtenduGauche = new Panel(); |
| conteneurChampEtenduGauche.setLayout(flmg); |
| conteneurChampEtenduDroite = new Panel(); |
| conteneurChampEtenduDroite.setLayout(flmd); |
| conteneurChampEtenduGauche.setAutoWidth(true); |
| conteneurChampEtenduGauche.setStyle("conteneurChampsEtendus"); |
| conteneurChampEtenduGauche.setBodyBorder(false); |
| conteneurChampEtenduDroite.setAutoWidth(true); |
| conteneurChampEtenduDroite.setStyle("conteneurChampsEtendus"); |
| conteneurChampEtenduDroite.setBodyBorder(false); |
| // pour corriger le décalage sur le panneau induit par le lien d'affichage |
| conteneurChampEtenduDroite.setPaddings(42, 0, 0, 0); |
| if(champsEtendus != null && champsEtendus.size() > 0) { |
| lienAfficherChampsEtendus.setVisible(true); |
| listeChampsEtendus = new HashMap<String, ChampSaisieEtendu>(champsEtendus.size()); |
| HashMap<String, String> correspondancesClesLabel = ListeReferentielChampsEtendusDAO.cacheClesLabels; |
| boolean gauche = true; |
| for (Iterator<String> iterator = champsEtendus.keySet().iterator(); iterator.hasNext();) { |
| String id = iterator.next(); |
| ChampEtendu champ = champsEtendus.get(id); |
| String valeur = champ.getValeur(); |
| String label = id; |
| // Si le champ possède un clé déjà définie par le catalogue, elle lui sera affectée |
| // sinon on la formate en la "déchamotant" et en ajoutant des espaces |
| if(correspondancesClesLabel.containsKey(id)) { |
| label = correspondancesClesLabel.get(id); |
| } else { |
| label = Util.formaterCleChampsEtenduPourAffichage(label); |
| } |
| ChampSaisieEtendu champTexteEtendu = new ChampSaisieEtendu(label, id, ListeReferentielChampsEtendusDAO.getUrlRequeteValeursChampEtendu(id)); |
| if(champ.equals(champsAFocus)) { |
| champTexteEtendu.focus(); |
| } |
| champTexteEtendu.setId(id); |
| champTexteEtendu.setValue(valeur); |
| if(gauche) { |
| conteneurChampEtenduGauche.add(champTexteEtendu); |
| } else { |
| conteneurChampEtenduDroite.add(champTexteEtendu); |
| } |
| listeChampsEtendus.put(id, champTexteEtendu); |
| gauche = !gauche; |
| } |
| panneauPremierColonne.add(conteneurChampEtenduGauche); |
| panneauSecondeColonne.add(conteneurChampEtenduDroite); |
| if(!afficherChampsEtendus) { |
| conteneurChampEtenduGauche.setVisible(false); |
| conteneurChampEtenduDroite.setVisible(false); |
| } else { |
| redimensionnerChampsEtendus(); |
| } |
| } else { |
| lienAfficherChampsEtendus.setVisible(false); |
| } |
| doLayout(); |
| } |
| private void redimensionnerChampsEtendus() { |
| int largeur = conteneurChampEtenduGauche.getWidth(); |
| if(largeur <= 0) { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| redimensionnerChampsEtendus(); |
| } |
| }; |
| t.schedule(150); |
| } else { |
| for (Iterator<String> iterator = listeChampsEtendus.keySet().iterator(); iterator |
| .hasNext();) { |
| ChampSaisieEtendu ch = listeChampsEtendus.get(iterator.next()); |
| ch.redimensionner(largeur - 15); |
| if(ch.getFieldWidth() < ch.getLabelWidth()) { |
| ch.addClass("panneauModePetiteLargeur"); |
| ch.agrandirChamp(largeur - 82); |
| } else { |
| //ch.removeClass("panneauModePetiteLargeur"); |
| } |
| } |
| } |
| } |
| private Map<String, ChampEtendu> getValeursChampsEtendus() { |
| Map<String, ChampEtendu> valeursChampsEtendus = new HashMap<String, ChampEtendu>(); |
| if(listeChampsEtendus != null) { |
| for (Iterator<String> it = listeChampsEtendus.keySet().iterator(); it.hasNext();) { |
| String cle = it.next(); |
| ChampSaisieEtendu champTexteEtendu = listeChampsEtendus.get(cle); |
| String label = champTexteEtendu.getLabel(); |
| String valeur = champTexteEtendu.getRawValue(); |
| ChampEtendu champEtendu = new ChampEtendu(cle, label, valeur); |
| valeursChampsEtendus.put(cle, champEtendu); |
| } |
| } |
| return valeursChampsEtendus; |
| } |
| public void raz() |
| { |
| raz(Champs.TOUT); |
| } |
| public void raz(Champs champs) |
| { |
| switch (champs) { |
| case DATE: |
| date.reset() ; |
| break; |
| case LIEUDIT: |
| lieudit.reset() ; |
| break; |
| case STATION: |
| station.reset() ; |
| break; |
| case MILIEU: |
| milieu.reset() ; |
| break; |
| case COMMENT: |
| comment.reset() ; |
| break; |
| case LOCALITE: |
| localite.reset() ; |
| codeLocalite =""; |
| pays=""; |
| latitude.reset(); |
| longitude.reset(); |
| break; |
| case ESPECE: |
| espece.reset(); |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| break; |
| case LATITUDE: |
| latitude.reset(); |
| afficherIndicationlocalite(null); |
| break; |
| case LONGITUDE: |
| longitude.reset(); |
| afficherIndicationlocalite(null); |
| break; |
| case ALTITUDE: |
| altitude.reset(); |
| break; |
| case ABONDANCE: |
| selecteurAbondance.setValue(""); |
| break; |
| case CERTITUDE: |
| selecteurCertitude.setValue(""); |
| break; |
| case REFERENTIELTAXO: |
| selecteurReferentielTaxo.setValue(""); |
| break; |
| case PHENOLOGIE: |
| selecteurStadePheno.setValue(""); |
| break; |
| case TOUT: |
| localite.reset(); |
| date.reset() ; |
| lieudit.reset() ; |
| station.reset() ; |
| milieu.reset() ; |
| comment.reset() ; |
| milieu.reset() ; |
| latitude.reset(); |
| longitude.reset(); |
| altitude.reset(); |
| pays=""; |
| codeLocalite =""; |
| espece.reset(); |
| selecteurAbondance.clearValue(); |
| selecteurCertitude.clearValue(); |
| selecteurReferentielTaxo.clearValue(); |
| selecteurStadePheno.clearValue(); |
| referentielTaxo = ""; |
| numeroNom = "" ; |
| numeroOrdre = ""; |
| afficherIndicationlocalite(null); |
| break; |
| } |
| } |
| 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 void setSelectionMultiple(boolean selectionMultiple) { |
| this.selectionMultiple = selectionMultiple; |
| if(!selectionMultiple) { |
| boutonReinitialiser.enable(); |
| boutonOK.enable(); |
| } else { |
| boutonReinitialiser.disable(); |
| boutonOK.disable(); |
| } |
| } |
| public boolean getSelectionMultiple() { |
| return selectionMultiple; |
| } |
| private void calculerAfficherDifferences(ListeObservation listeObs) { |
| String codeLocalite = null; |
| String pays = null; |
| String localite = null; |
| String lieuDit = null; |
| String station = null; |
| String milieu = null; |
| String espece = null; |
| String date = null; |
| String notes = null; |
| String lat = null; |
| String lon = null; |
| String alt = null; |
| String abondance = null; |
| String certitude = null; |
| String referentielTaxo = null; |
| String phenologie = null; |
| String ordreObs = ""; |
| for(Iterator<String> it = listeObs.keySet().iterator();it.hasNext();) { |
| Observation obsEnCours = listeObs.get(it.next()); |
| pays = comparerDifferencesChamps(pays, obsEnCours.getPays()); |
| codeLocalite = comparerDifferencesChamps(codeLocalite, obsEnCours.getIdentifiantLocalite()); |
| localite = comparerDifferencesChamps(localite, obsEnCours.getLocalite()); |
| lieuDit = comparerDifferencesChamps(lieuDit, obsEnCours.getLieudit()); |
| station = comparerDifferencesChamps(station, obsEnCours.getStation()); |
| milieu = comparerDifferencesChamps(milieu, obsEnCours.getMilieu()); |
| espece = comparerDifferencesChamps(espece, obsEnCours.getNomSaisi()); |
| date = comparerDifferencesChamps(date, obsEnCours.getDate()); |
| notes = comparerDifferencesChamps(notes, obsEnCours.getCommentaire()); |
| lat = comparerDifferencesChamps(lat, obsEnCours.getLatitude()); |
| lon = comparerDifferencesChamps(lon, obsEnCours.getLongitude()); |
| alt = comparerDifferencesChamps(alt, obsEnCours.getAltitude()); |
| abondance = comparerDifferencesChamps(abondance, obsEnCours.getAbondance()); |
| certitude = comparerDifferencesChamps(certitude, obsEnCours.getCertitude()); |
| referentielTaxo = comparerDifferencesChamps(referentielTaxo, obsEnCours.getReferentielTaxo()); |
| phenologie = comparerDifferencesChamps(phenologie, obsEnCours.getPhenologie()); |
| ordreObs += obsEnCours.getNumeroOrdre()+","; |
| } |
| Observation obs=new Observation(espece,numeroNom,localite,codeLocalite,lieuDit,station,milieu, notes,date); |
| obs.setPays(pays); |
| obs.setNumeroOrdre(ordreObs); |
| obs.setLatitude(lat); |
| obs.setLongitude(lon); |
| obs.setAltitude(alt); |
| obs.setAbondance(abondance); |
| obs.setCertitude(certitude); |
| obs.setReferentielTaxo(referentielTaxo); |
| obs.setPhenologie(phenologie); |
| afficherDetailsObservation(obs); |
| } |
| private String comparerDifferencesChamps(String valeurActuelle, String nouvelleValeur) { |
| String retour = ""; |
| if(valeurActuelle == null) { |
| retour = nouvelleValeur; |
| } else { |
| if(valeurActuelle.equals(nouvelleValeur)) { |
| retour = valeurActuelle; |
| } else { |
| retour = VALEURS_MULTIPLES; |
| } |
| } |
| return retour; |
| } |
| private void reinitialiserValeurModifiees() { |
| localiteModifiee = false; |
| lieuDitModifie = false; |
| stationModifiee = false; |
| milieuModifie = false; |
| dateModifiee = false; |
| especeModifiee = false; |
| commModifie = false; |
| latModifiee = false; |
| longModifiee = false; |
| altModifiee = false; |
| abondanceModifiee = false; |
| certitudeModifiee = false; |
| referentielTaxoModifie = false; |
| phenologieModifiee = false; |
| } |
| public void saisieTabindex() |
| { |
| localite.setTabIndex(1); |
| lieudit.setTabIndex(3); |
| station.setTabIndex(4); |
| milieu.setTabIndex(5); |
| coordonnees.setTabIndex(-1); |
| coordonnees.addListener(new TextFieldListenerAdapter() { |
| @Override |
| public void onFocus(Field field) { |
| if(coordPanel.isVisible()) { |
| latitude.focus(); |
| } else { |
| Ext.get("lien_carto").focus(); |
| } |
| } |
| }); |
| latitude.setTabIndex(8); |
| longitude.setTabIndex(9); |
| altitude.setTabIndex(10); |
| comment.setTabIndex(11); |
| date.setTabIndex(12); |
| espece.setTabIndex(13); |
| selecteurCertitude.setTabIndex(14); |
| selecteurAbondance.setTabIndex(15); |
| selecteurStadePheno.setTabIndex(16); |
| boutonOK.setTabIndex(17); |
| boutonReinitialiser.setTabIndex(18); |
| } |
| private void obtenirInformationCoord() { |
| if(coordonneesValides() != null) { |
| observationMediateur.obtenirInformationCoord(coordonneesValides()[0],coordonneesValides()[1]); |
| } else { |
| // Centrage de la carte sur une zone correspondant plus ou moins au référentiel. |
| // En dur car la config est tellement mal foutue que j'ai envie de me pendre. |
| String referentiel = this.getReferentielTaxo(); |
| String referentielRacine = referentiel.substring(0, referentiel.indexOf(':')); |
| Double lat = null, lon = null; |
| int zoom = 6; |
| switch(referentielRacine) { |
| case "bdtre" : |
| lat = -21.10; |
| lon = 55.30; |
| zoom = 7; |
| break; |
| case "isfan" : |
| lat = 29.28358; |
| lon = 10.21884; |
| zoom = 5; |
| break; |
| case "apd" : |
| lat = 8.75624; |
| lon = 1.80176; |
| zoom = 5; |
| break; |
| case "bdtxa" : |
| lat = 14.6; |
| lon = -61.08334; |
| zoom = 7; |
| break; |
| case "lbf" : |
| lat = 33.53; |
| lon = 35.30; |
| zoom = 7; |
| break; |
| case "bdtfx" : |
| default: |
| lat = 47.0504; |
| lon = 2.2347; |
| zoom = 6; |
| } |
| if (lat != null && lon != null) { |
| // centrage sur la zone |
| EntiteGeographiqueObservation infos = new EntiteGeographiqueObservation(); |
| infos.setLon("" + lon); |
| infos.setLat("" + lat); |
| infos.setZoom(zoom); |
| observationMediateur.rafraichirFenetreCartoSurPoint(infos); |
| } else { |
| // affichage par défaut au cas où on n'aurait pas trouvé de coordonnées pour centrer |
| observationMediateur.afficherFenetreCarto(); |
| } |
| } |
| } |
| private void obtenirInformationLocalite() { |
| String idLoc = obtenirIdLocalite(); |
| observationMediateur.obtenirInformationLocalite(getlocaliteSansIdLoc(), idLoc); |
| } |
| private String obtenirIdLocalite() { |
| String idLoc = ""; |
| // Soit un numéro de département, soit un code de pays à deux lettres |
| String[] codeCom = localite.getText().split(" "); |
| if(codeCom.length > 1 && ressembleAUnCodePaysOuDepartement(codeCom[codeCom.length - 1])) { |
| String codeLoc = codeCom[codeCom.length - 1].replace('(', ' '); |
| codeLoc = codeLoc.replace(')', ' ').trim().replace('\\',' ').trim(); |
| if(Util.estUnNombre(codeLoc)) { |
| idLoc = codeLoc ; |
| } else { |
| idLoc = codeLoc.toUpperCase(); |
| } |
| } |
| return idLoc; |
| } |
| public double[] coordonneesValides() { |
| try { |
| double lat = Double.parseDouble(latitude.getValueAsString().replaceAll(",", ".")); |
| double lon = Double.parseDouble(longitude.getValueAsString().replaceAll(",", ".")); |
| double[] coord = {lat, lon}; |
| return coord; |
| } catch (NumberFormatException ne) { |
| return null; |
| } |
| } |
| private String[] getValeurCoordonnees() { |
| double[] coDouble = coordonneesValides(); |
| if(coDouble != null) { |
| String[] coord = {coDouble[0]+"",coDouble[1]+""}; |
| return coord; |
| } else { |
| String[] coord = {"","" }; |
| return coord; |
| } |
| } |
| public String getlocalite() { |
| String valeurlocalite = ""; |
| if(localite.getText() != null) { |
| valeurlocalite = localite.getText(); |
| } |
| return valeurlocalite; |
| } |
| public String getlocaliteSansIdLoc() { |
| return Util.supprimerChaineIdLocalite(getlocalite()); |
| } |
| private String getValeurChampListeLibre(ComboBox champ) { |
| String valeurChamp = champ.getValue(); |
| String valeurChampBrute = champ.getRawValue(); |
| // Test idiot qui permet de savoir si l'on utilise la valeur saisie directement ou bien la valeur |
| // selectionnee car lors du setValue sur le keypress, gwtext ne prends pas en compte le dernier |
| // caractère |
| if(valeurChampBrute.trim().length() == 0) { |
| valeurChamp = ""; |
| } else { |
| if(valeurChamp != null && valeurChamp.length() > 0) { |
| if(valeurChamp.equals(valeurChampBrute.substring(0, valeurChampBrute.length() -1))) { |
| valeurChamp = champ.getRawValue(); |
| } |
| } |
| } |
| return valeurChamp; |
| } |
| public String getAbondance() { |
| return getValeurChampListeLibre(selecteurAbondance); |
| } |
| public String getCertitude() { |
| return getValeurChampListeLibre(selecteurCertitude); |
| } |
| public String getPhenologie() { |
| return getValeurChampListeLibre(selecteurStadePheno); |
| } |
| public String getReferentielTaxo() { |
| String codeCourt = getValeurChampListeLibre(selecteurReferentielTaxo); |
| return Ontologies.getInfosReferentielNomParCode(codeCourt).getCodeVersionComplet(); |
| } |
| public boolean localiteInitialisee() { |
| return localiteModifiee; |
| } |
| public void redimensionnerFormulaire() { |
| afficherFormulaireLatLon.setWidth(panneauIntermediaire.getWidth()+"px"); |
| panneauPremierColonne.doLayout(); |
| panneauSecondeColonne.doLayout(); |
| panneauIntermediaire.doLayout(); |
| doLayout(); |
| } |
| private void verifierPresenceTaxonSaisi() { |
| affecterCodeLocaliteOuPays(); |
| if(!enRequeteChrologie && !codeLocalite.isEmpty() && numeroNom != null && !numeroNom.isEmpty()) { |
| enRequeteChrologie = true; |
| // Pour le moment, si on a un code localité, c'est qu'on est en France |
| final String paysStr = pays.isEmpty() ? "FR" : pays; |
| final String cleCache = numeroNom.trim()+paysStr.trim()+codeLocalite.trim(); |
| // Pour éviter de vérifier et d'afficher plus d'une fois l'avertissement de présence |
| if(!avertissementPresence.containsKey(numeroNom.trim()+paysStr.trim()+codeLocalite.trim())) { |
| // Pour l'instant c'est toujours France mais il serait bon un jour d'avoir une chorologie multi pays. |
| // donc ça ne coute rien de le gérer déjà ici dans l'interface |
| ImageInformationRepartitionAsynchroneDAO.taxonEstPresentDansZoneGeo(referentielTaxo, numeroNom, paysStr, codeLocalite, new Callback<String, String>() { |
| @Override |
| public void onSuccess(String result) { |
| // En cas d'absence d'infos sur la zone le service retourne "" (chaîne vide) |
| // En cas de non signalement dans la zone, il retourne 0, |
| // En cas de présence, il retourne 1 |
| if(result.equals("0")) { |
| // L'absence explicite est le seul cas qui nous interesse |
| String[] stParams = {espece.getText(), codeLocalite, Configuration.getChorologieAvertissementCourriel()}; |
| String message = Msg.get("indication-premiere-presence", stParams); |
| Window.alert(message); |
| } |
| avertissementPresence.put(cleCache, result); |
| enRequeteChrologie = false; |
| } |
| @Override |
| public void onFailure(String reason) { |
| enRequeteChrologie = false; |
| } |
| }); |
| } else { |
| enRequeteChrologie = false; |
| } |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/PanneauFiltresObservationVues.java |
|---|
| New file |
| 0,0 → 1,180 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreDateObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreEntiteGeographiqueObservationFiltreVue; |
| import org.tela_botanica.client.vues.observation.filtres.ArbreMotsClesObservationVue; |
| import org.tela_botanica.client.vues.observation.filtres.RechercheLibreVue; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| /** |
| * Panneau contenant les filtres qu'on peut appliquer aux images |
| * |
| * @author aurelien |
| * |
| */ |
| public class PanneauFiltresObservationVues extends Panel { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * L'arbre pour la recherche entite geographique |
| * |
| */ |
| private ArbreEntiteGeographiqueObservationFiltreVue arbreEntiteGeographiqueObservationFiltreVue = null; |
| /** |
| * L'arbre pour la recherche date |
| * |
| */ |
| private ArbreDateObservationFiltreVue arbreDateObservationFiltreVue = null; |
| private ArbreMotsClesObservationVue arbreMotsClesObservationVue = null ; |
| private RechercheLibreVue rechercheLibreVue = null; |
| /** |
| * Construcuteur sans argument (privé car on ne doit pas l'utiliser) |
| */ |
| @SuppressWarnings("unused") |
| private PanneauFiltresObservationVues() { |
| super(); |
| } |
| /** |
| * Constructeur avec arguments |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public PanneauFiltresObservationVues(ObservationMediateur obs) { |
| super(Msg.get("filtres")); |
| observationMediateur = obs; |
| this.setCollapsible(true); |
| //this.setLayout(new AnchorLayout()) ; |
| this.setLayout(new RowLayout()); |
| rechercheLibreVue = new RechercheLibreVue(observationMediateur); |
| if(Ext.isIE()) { |
| add(rechercheLibreVue); |
| rechercheLibreVue.setHeight(110); |
| } else { |
| add(rechercheLibreVue,new RowLayoutData(100)); |
| } |
| rechercheLibreVue.setWidth("100%") ; |
| rechercheLibreVue.setBorder(false); |
| arbreEntiteGeographiqueObservationFiltreVue = new ArbreEntiteGeographiqueObservationFiltreVue(observationMediateur); |
| add(arbreEntiteGeographiqueObservationFiltreVue,new RowLayoutData()); |
| //arbreEntiteGeographiqueObservationFiltreVue.setHeight(300) ; |
| arbreEntiteGeographiqueObservationFiltreVue.setWidth("100%") ; |
| arbreEntiteGeographiqueObservationFiltreVue.setBorder(false); |
| arbreDateObservationFiltreVue = new ArbreDateObservationFiltreVue(observationMediateur) ; |
| //arbreDateObservationFiltreVue.setHeight(300) ; |
| add(arbreDateObservationFiltreVue, new RowLayoutData()); |
| arbreDateObservationFiltreVue.setWidth("100%") ; |
| arbreDateObservationFiltreVue.setBorder(false); |
| arbreMotsClesObservationVue = new ArbreMotsClesObservationVue(observationMediateur); |
| add(arbreMotsClesObservationVue, new RowLayoutData()); |
| arbreMotsClesObservationVue.setWidth("100%") ; |
| arbreMotsClesObservationVue.setTitle(Msg.get("projets")); |
| arbreMotsClesObservationVue.setTitleCollapse(true); |
| arbreMotsClesObservationVue.setCollapsible(true); |
| arbreMotsClesObservationVue.setBorder(false); |
| } |
| /** |
| * Accesseur pour le filtre des mots clés |
| * |
| * @return le filtre des mots clés |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue getArbreEntiteGeographiqueObservationFiltreVue() { |
| return arbreEntiteGeographiqueObservationFiltreVue; |
| } |
| public ArbreDateObservationFiltreVue getArbreDateObservationFiltreVue() { |
| return arbreDateObservationFiltreVue; |
| } |
| public ArbreMotsClesObservationVue getArbreMotsClesObservationVue() { |
| return arbreMotsClesObservationVue; |
| } |
| public RechercheLibreVue getRechercheLibreVue() { |
| return rechercheLibreVue; |
| } |
| /** |
| * Renvoie un booléen indiquant si un des filtres a été modifié |
| * |
| * @return true sur un des filtres est modifié, false sinon |
| */ |
| public boolean renvoyerEtatFiltre() { |
| return (arbreEntiteGeographiqueObservationFiltreVue.renvoyerEtatFiltre() || arbreDateObservationFiltreVue.renvoyerEtatFiltre() || rechercheLibreVue.renvoyerEtatFiltre()); |
| } |
| /** |
| * Renvoie un tableau à 2 niveaux contenant des paires "nom_de_filtre", |
| * "valeur" |
| * |
| * @return un tableau contenant les noms et les valeurs à filtrer |
| */ |
| public String[][] renvoyerValeursAFiltrer() { |
| String[][] filtres = { arbreEntiteGeographiqueObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreDateObservationFiltreVue.renvoyerValeursAFiltrer(), |
| arbreMotsClesObservationVue.renvoyerValeursAFiltrer(), |
| rechercheLibreVue.renvoyerValeursAFiltrer() |
| }; |
| return filtres; |
| } |
| public void viderFiltres() { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(); |
| arbreDateObservationFiltreVue.viderFiltre(); |
| arbreMotsClesObservationVue.viderFiltre(); |
| rechercheLibreVue.viderFiltre(); |
| } |
| public void viderFiltres(String nom) { |
| if(nom.equals("id_mots_cles")) { |
| arbreMotsClesObservationVue.viderFiltre(); |
| } |
| if(nom.equals("recherche")) { |
| rechercheLibreVue.viderFiltre(); |
| } |
| if(nom.equals("annee") || nom.equals("mois") || nom.equals("jour")) { |
| arbreDateObservationFiltreVue.viderFiltre(nom); |
| } |
| if(nom.equals("pays") || nom.equals("station") || nom.equals("lieudit") || nom.equals("departement") || nom.equals("localite")) { |
| arbreEntiteGeographiqueObservationFiltreVue.viderFiltre(nom); |
| } |
| } |
| } |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/MenuObservationVue.java |
|---|
| New file |
| 0,0 → 1,106 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| public class MenuObservationVue extends Menu { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur; |
| /** |
| * Item pour la suppression d'obs |
| */ |
| private Item supprimerObservation = null; |
| private Item transmettreObservation = null; |
| private Item deTransmettreObservation = null; |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MenuObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public MenuObservationVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| transmettreObservation = new Item(Msg.get("rendre-publiques-selectionnees")); |
| addItem(transmettreObservation); |
| deTransmettreObservation = new Item(Msg.get("rendre-privees-selectionnees")); |
| addItem(deTransmettreObservation); |
| supprimerObservation = new Item(Msg.get("supprimer-selectionnees")); |
| addItem(supprimerObservation); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions des évènements |
| */ |
| private void ajouterListeners() { |
| this.addListener(new MenuListenerAdapter() { |
| // gestion du clic sur un item |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est la suppression |
| if (item.equals(supprimerObservation)) { |
| // on notifie le médiateur |
| getOMediateur().supprimerObservations(); |
| } |
| // si c'est la transmission |
| if (item.equals(transmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(true); |
| } |
| // si c'est la detransmission |
| if (item.equals(deTransmettreObservation)) { |
| // on notifie le médiateur |
| getOMediateur().transmettreObservations(false); |
| } |
| // enfin, on cache le menu |
| hide(); |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/CartographieObservationVue.java |
|---|
| New file |
| 0,0 → 1,430 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| 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.widgets.Container; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
| import com.gwtext.client.widgets.form.Label; |
| import com.gwtext.client.widgets.layout.FitLayout; |
| import com.gwtext.client.widgets.layout.RowLayout; |
| import com.gwtext.client.widgets.layout.RowLayoutData; |
| import com.google.maps.gwt.client.GoogleMap; |
| import com.google.maps.gwt.client.GoogleMap.ClickHandler; |
| import com.google.maps.gwt.client.GoogleMap.ZoomChangedHandler; |
| import com.google.maps.gwt.client.InfoWindow; |
| import com.google.maps.gwt.client.InfoWindowOptions; |
| import com.google.maps.gwt.client.LatLng; |
| import com.google.maps.gwt.client.MapOptions; |
| import com.google.maps.gwt.client.MapTypeId; |
| import com.google.maps.gwt.client.Marker; |
| import com.google.maps.gwt.client.MarkerOptions; |
| import com.google.maps.gwt.client.MouseEvent; |
| public class CartographieObservationVue extends Panel implements Rafraichissable { |
| private String id = "cartographie_observation"; |
| private ObservationMediateur oMediateur = null; |
| Panel panneauCarto = null; |
| GoogleMap map = null; |
| Marker nmk = null; |
| private boolean carteAjoutee = false; |
| private boolean infoOuverte = false; |
| String valeurLocalite = "Bourges"; // j'aurais préféré Bort-les-Orgues |
| LatLng centreFrance = null; |
| LatLng pointLocalite = null; |
| String codeLoc = ""; |
| String pays = ""; |
| int niveauZoom = 6; |
| Label panneauExplication = new Label(Msg.get("explication-panneau-carto")); |
| private InfoWindow info; |
| private boolean zoomerSurRetour = false; |
| public CartographieObservationVue(ObservationMediateur om) { |
| oMediateur = om; |
| setHeader(false); |
| setAutoWidth(true); |
| setPaddings(10); |
| panneauCarto = new Panel(); |
| panneauCarto.setLayout(new FitLayout()); |
| setLayout(new RowLayout()); |
| panneauCarto.setAutoHeight(true); |
| add(panneauExplication, new RowLayoutData(12)); |
| add(panneauCarto, new RowLayoutData()); |
| addListener(new ContainerListenerAdapter() { |
| @Override |
| public void onAfterLayout(Container c) { |
| initialiserCarte(false); |
| } |
| }); |
| } |
| public void setTailleCarte(int hauteur, int largeur) { |
| setSize(largeur, hauteur); |
| } |
| public void masquerChargement(boolean masquer) { |
| if(panneauCarto.isVisible()) { |
| if(masquer) { |
| panneauCarto.getEl().mask(Msg.get("recherche-coordonnees-localite")); |
| } else { |
| panneauCarto.getEl().unmask(); |
| } |
| } |
| } |
| public void obtenirInfosLocalites(LatLng coord) { |
| // Remise à zéro des infos restantes d'une ancienne requete |
| valeurLocalite = ""; |
| codeLoc = ""; |
| pays = ""; |
| oMediateur.obtenirInformationCoord(this, coord.lat(), coord.lng()); |
| } |
| public void mettreAJourInfos(final LatLng pointNouvelleLocalite, int zoom) { |
| GoogleMap mapNulle = null; |
| if(nmk != null) { |
| nmk.setMap(mapNulle); |
| } |
| pointLocalite = pointNouvelleLocalite; |
| nmk = fabriquerMarqueur(pointLocalite); |
| nmk.setMap(map); |
| afficherInfoMarker(nmk, construireContenuInfoMarker(nmk)); |
| recentrerCarte(nmk.getPosition()); |
| map.setZoom(zoom); |
| } |
| private void initialiserCarte(boolean localite) { |
| panneauCarto.clear(); |
| centreFrance = LatLng.create(47.0504, 2.2347); |
| pointLocalite = centreFrance; |
| MapOptions options = MapOptions.create(); |
| options.setCenter(centreFrance); |
| options.setZoom(6); |
| options.setMapTypeId(MapTypeId.HYBRID); |
| options.setDraggable(true); |
| options.setMapTypeControl(true); |
| options.setScaleControl(true); |
| options.setScrollwheel(true); |
| map = GoogleMap.create(panneauCarto.getElement(), options ); |
| InfoWindowOptions infopts = InfoWindowOptions.create(); |
| info = InfoWindow.create(); |
| info.setOptions(infopts); |
| info.addCloseClickListener(new InfoWindow.CloseClickHandler() { |
| @Override |
| public void handle() { |
| infoOuverte = false; |
| } |
| }); |
| if(!localite) { |
| fabriquerMarqueurIndication(); |
| } |
| map.addClickListener(new ClickHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| obtenirInfosLocalites(event.getLatLng()); |
| } |
| }); |
| map.addZoomChangedListener(new ZoomChangedHandler() { |
| @Override |
| public void handle() { |
| niveauZoom = (int)map.getZoom(); |
| } |
| }); |
| panneauCarto.doLayout(); |
| panneauCarto.expand(); |
| panneauCarto.setHeight("100%"); |
| panneauCarto.setWidth("100%"); |
| expand(); |
| } |
| public void fabriquerMarqueurIndication() { |
| GoogleMap mapNulle = null; |
| if(nmk != null) { |
| nmk.setMap(mapNulle); |
| } |
| nmk = fabriquerMarqueur(pointLocalite); |
| nmk.setMap(map); |
| info.setContent("<div id=\"info_contenu\">"+ |
| Msg.get("deplacez-marqueur-pour-localiser") + "<br/>" |
| +"longitude=" |
| + Util.tronquerNombrePourAffichage("" + nmk.getPosition().lng(), 5) + "<br />latitude=" |
| + Util.tronquerNombrePourAffichage("" + nmk.getPosition().lat(), 5) + "</div>"); |
| infoOuverte = true; |
| info.open(map,nmk); |
| } |
| public void AfficherMessageAucuneInfos() { |
| mettreAJourInfos(centreFrance, niveauZoom); |
| Window.alert(Msg.get("aucune-information")); |
| } |
| public int getNiveauZoom() { |
| return niveauZoom; |
| } |
| private void ajouterListenerBouton(final String idBouton) { |
| final ExtElement bouton = Ext.get(idBouton); |
| if(bouton == null) { |
| Timer t = new Timer() { |
| @Override |
| public void run() { |
| ajouterListenerBouton(idBouton); |
| } |
| }; |
| t.schedule(500); |
| return; |
| } else { |
| bouton.addListener("click", new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| EntiteGeographiqueObservation infosLocalite = new EntiteGeographiqueObservation(codeLoc,valeurLocalite,null,null); |
| infosLocalite.setPays(pays); |
| infosLocalite.setLat(pointLocalite.lat()+""); |
| infosLocalite.setLon(pointLocalite.lng()+""); |
| oMediateur.rafraichirSaisieLocaliteObservation(infosLocalite); |
| } |
| }); |
| bouton.focus(); |
| } |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| // rétablissement du curseur, parfois mis sur "attente" par le processus chargeant la carte |
| Util.curseurParDefaut(); |
| if (nouvelleDonnees instanceof String) { |
| if(isVisible()) { |
| Window.alert((String)nouvelleDonnees); |
| } |
| } |
| if (nouvelleDonnees instanceof EntiteGeographiqueObservation) { |
| oMediateur.afficherFenetreCarto(); |
| EntiteGeographiqueObservation infos = (EntiteGeographiqueObservation) nouvelleDonnees; |
| Double lat = 0.0; |
| Double lon = 0.0; |
| try { |
| lat = Double.parseDouble(infos.getLat()); |
| lon = Double.parseDouble(infos.getLon()); |
| } catch (NumberFormatException nbe) { |
| } |
| LatLng coord = LatLng.create(lat, lon); |
| // si on a un point, on zoome fort dès le début |
| if (zoomerSurRetour) { |
| niveauZoom = 16; |
| zoomerSurRetour = false; |
| } else if (infos.getZoom() > 0) { |
| niveauZoom = infos.getZoom(); |
| } |
| String nouvelleValeurLocalite = infos.getZoneGeo(); |
| valeurLocalite = nouvelleValeurLocalite; |
| codeLoc = ""; |
| if(infos.getIdZoneGeo() != null) { |
| // Quoi stocker pour en dehors de la france ? |
| if (infos.getPays().equals("FR")) { |
| codeLoc = Util.convertirChaineZoneGeoVersDepartement(infos.getIdZoneGeo()); |
| } else { |
| codeLoc = infos.getPays(); |
| } |
| } |
| pays = infos.getPays(); |
| pointLocalite = coord; |
| mettreAJourInfos(coord, niveauZoom); |
| } |
| masquerChargement(false); |
| } |
| public Marker fabriquerMarqueur(LatLng pointMarqueur) { |
| // ajout de marqueurs déplacables, qui affichent une bulle d'information |
| MarkerOptions options = MarkerOptions.create(); |
| options.setDraggable(true); |
| options.setPosition(pointMarqueur); |
| final Marker marker = Marker.create(options); |
| marker.addDragEndListener(new Marker.DragEndHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| afficherInfoMarker(marker, construireContenuPartielInfoMarker(marker)); |
| obtenirInfosLocalites(event.getLatLng()); |
| } |
| }); |
| marker.addDragStartListener(new Marker.DragStartHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| info.close(); |
| } |
| }); |
| marker.addClickListener(new Marker.ClickHandler() { |
| @Override |
| public void handle(MouseEvent event) { |
| if(infoOuverte) { |
| info.close(); |
| infoOuverte = false; |
| } else { |
| afficherInfoMarker(marker, construireContenuPartielInfoMarker(marker)); |
| infoOuverte = true; |
| } |
| } |
| }); |
| return marker; |
| } |
| public void recentrerCarte() { |
| if(nmk != null && nmk.getVisible()) { |
| recentrerCarte(nmk.getPosition()); |
| } |
| } |
| public void recentrerCarte(LatLng point) { |
| if(this.getWidth() > 12 && this.getHeight() > 24) { |
| panneauCarto.setSize((this.getWidth() - 12)+"px" , (this.getHeight() - 12)+"px"); |
| } |
| panneauCarto.doLayout(); |
| panneauCarto.expand(); |
| panneauCarto.setHeight("100%"); |
| panneauCarto.setWidth("100%"); |
| expand(); |
| map.setCenter(point); |
| } |
| public boolean isCarteAjoutee() { |
| return carteAjoutee; |
| } |
| public String construireContenuInfoMarker(Marker marker) { |
| final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>"; |
| String contenuMarker = ""; |
| if(valeurLocalite == null || valeurLocalite.trim().equals("")) { |
| if(marker.getPosition().lng() == 0 && marker.getPosition().lat() == 0) { |
| LatLng point = centreFrance; |
| marker.setPosition(point); |
| niveauZoom = 6; |
| } |
| contenuMarker = |
| "<div id=\"info_contenu\">"+ |
| Msg.get("aucun-lieu-trouve") + " <br/>" |
| +Msg.get("deplacez-marqueur-pour-localiser") + " <br />" |
| +"longitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lng(), 5)+"<br />" |
| +"latitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lat(), 5)+ |
| "</div>"; |
| } else { |
| String chaineLocalite = valeurLocalite + ((codeLoc.isEmpty()) ? "" : " ("+codeLoc+")"); |
| contenuMarker = |
| "<div id=\"info_contenu\">"+ |
| chaineLocalite+"<br />" |
| +"longitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lng(), 5)+"<br />" |
| +"latitude="+Util.tronquerNombrePourAffichage(""+marker.getPosition().lat(), 5)+ |
| "</div>"; |
| } |
| return contenuMarker+ htmlBoutonOk; |
| } |
| public String construireContenuPartielInfoMarker(Marker marker) { |
| final String htmlBoutonOk = "<br /><button id=\"okMap\" class=\"x-btn-text\" type=\"button\">OK</button>"; |
| String contenuMarker = ""; |
| contenuMarker = |
| "<div id=\"info_contenu\">"+ |
| "<div class=\"recherche_infos_zone_geo\">"+ |
| "<div class=\"recherche_infos_zone_geo_en_cours\">"+ |
| "<img src=\"chargement_carte.gif\" />"+ |
| "<div>"+ |
| Msg.get("recherche-nom-lieu") + "<br />"+ |
| Msg.get("prendre-un-moment") + |
| "</div>"+ |
| "<hr class=\"nettoyage\" />"+ |
| "</div>"+ |
| Msg.get("que-les-coordonnees") + |
| "</div>"+ |
| "longitude="+Util.tronquerNombrePourAffichage("" + marker.getPosition().lng(), 5)+"<br />"+ |
| "latitude="+Util.tronquerNombrePourAffichage("" + marker.getPosition().lat(), 5)+ |
| "</div>"; |
| return contenuMarker+ htmlBoutonOk; |
| } |
| public void afficherInfoMarker(Marker marker, String contenuInfo) { |
| info.setContent(contenuInfo); |
| info.open(map, marker); |
| pointLocalite = marker.getPosition(); |
| info.addDomReadyListenerOnce(new InfoWindow.DomReadyHandler() { |
| @Override |
| public void handle() { |
| ajouterListenerBouton("okMap"); |
| } |
| }); |
| recentrerCarte(marker.getPosition()); |
| } |
| public void afficherCarteEnAttenteAvecMarker(double lat, double lon) { |
| pointLocalite = LatLng.create(lat, lon); |
| nmk.setPosition(pointLocalite); |
| afficherInfoMarker(nmk, construireContenuPartielInfoMarker(nmk)); |
| } |
| public double[] getCoordsCentreFrance() { |
| double[] coords = {47.0504, 2.2347}; |
| return coords; |
| } |
| public void setDoitZoomerSurRetour(boolean b) { |
| zoomerSurRetour = b; |
| } |
| } |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/SaisieMotsClesVue.java |
|---|
| New file |
| 0,0 → 1,211 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextArea; |
| public class SaisieMotsClesVue extends Window implements Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| private Object[][] listeMotsPesee = null; |
| private String motsAAjouter = "" ; |
| private int nbMotsClesMax = 1 ; |
| private TextArea motsClesAjout = null; |
| private Button validerAjout = null ; |
| private Button voirCacherNuage = null; |
| private boolean nuageVisible = false ; |
| private Panel contenuNuage = null ; |
| public SaisieMotsClesVue(ObservationMediateur om) { |
| super("Entrez vos mots clés"); |
| setCls("fenmotcles"); |
| oMediateur = om ; |
| //setWidth(300); |
| motsClesAjout = new TextArea(); |
| //motsClesAjout.setWidth(300); |
| validerAjout = new Button("Valider"); |
| voirCacherNuage= new Button("Afficher les mots clés"); |
| final Rafraichissable r = this ; |
| this.setCloseAction(CLOSE); |
| validerAjout.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| motsAAjouter = motsClesAjout.getText(); |
| //oMediateur.AjouterMotsClesEnMasse(motsAAjouter); |
| } |
| }); |
| voirCacherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| if(nuageVisible) { |
| if(contenuNuage != null) { |
| contenuNuage.clear(); |
| } |
| voirCacherNuage.setText("Afficher les mots clés"); |
| nuageVisible = false; |
| } |
| else { |
| // oMediateur.obtenirNuageMotsCles(r); |
| voirCacherNuage.setText("Cacher les mots clés"); |
| nuageVisible = true; |
| } |
| } |
| }); |
| add(motsClesAjout); |
| add(validerAjout); |
| add(voirCacherNuage); |
| contenuNuage = new Panel(); |
| contenuNuage.setBorder(false); |
| add(contenuNuage); |
| } |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public String[] renvoyerValeursAFiltrer() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof Integer) { |
| nbMotsClesMax = (Integer)nouvelleDonnees; |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof Object[][]) { |
| listeMotsPesee = (Object[][])nouvelleDonnees ; |
| construireNuage(); |
| demasquerChargement(); |
| } |
| if(nouvelleDonnees instanceof String) { |
| String res = (String)nouvelleDonnees; |
| if(res.equals("OK")) { |
| masquerChargement(); |
| oMediateur.obtenirListeObservation(); |
| //oMediateur.obtenirNuageMotsCles(this); |
| } |
| } |
| } |
| private void construireNuage() { |
| contenuNuage.clear(); |
| String contenu = "<ul class=\"nuagetag\">" ; |
| for(int i = 0; i<listeMotsPesee.length; i++) { |
| String classeMotCle = "motcletaille"+calculerPoids((Integer)listeMotsPesee[i][1]) ; |
| contenu += "<li class=\""+classeMotCle+"\">"; |
| contenu += (String)listeMotsPesee[i][0]; |
| contenu += "</li>"; |
| } |
| contenu += "</ul>" ; |
| HTML contenuHTML = new HTML(contenu) { |
| @Override |
| public void onBrowserEvent(Event e) { |
| motsAAjouter += " "+e.getTarget().getInnerHTML(); |
| motsClesAjout.setValue(motsAAjouter); |
| } |
| }; |
| contenuHTML.sinkEvents(Event.ONCLICK); |
| contenuNuage.add(contenuHTML); |
| contenuNuage.doLayout(); |
| doLayout(); |
| } |
| private int calculerPoids(int poidMot) { |
| int poids = (poidMot*10)/nbMotsClesMax; |
| if(poids < 1) { |
| return 1; |
| } |
| return poids; |
| } |
| /** |
| * 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() ; |
| } |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/filtres/ArbreMotsClesObservationVue.java |
|---|
| New file |
| 0,0 → 1,785 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.MotsClesUtilitaire; |
| import com.google.gwt.user.client.Window; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.dd.DragData; |
| import com.gwtext.client.dd.DragDrop; |
| 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.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| import com.gwtext.client.widgets.layout.VerticalLayout; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| import com.gwtext.client.widgets.tree.DropNodeCallback; |
| import com.gwtext.client.widgets.tree.MultiSelectionModel; |
| import com.gwtext.client.widgets.tree.TreeDragData; |
| import com.gwtext.client.widgets.tree.TreeEditor; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| public class ArbreMotsClesObservationVue extends Panel implements Rafraichissable, Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private static TreePanel arbreMotsCles = null; |
| /** |
| * L'éditeur qui permet de modifier les mots clés dans l'arbre |
| */ |
| private TreeEditor te = null; |
| /** |
| * Le textfield associé à l'éditeur |
| */ |
| private TextField tfEdit = null; |
| /** |
| * Bouton de validation |
| */ |
| private Button ajouterMotCle = null; |
| /** |
| * Une string permettant connaitre les mots clés cochés en cours séparés par |
| * des virgules |
| */ |
| private String motsClesEnCours = ""; |
| /** |
| * Tableau contenant les mots clés qui n'ont pas encore été jaouté à l'arbre |
| * (sert au lazy rendering quand on reçoit des mots clés avant que le rendu |
| * du conteneur n'ai été effectué) |
| */ |
| private String[] motsClesEnAttente = new String[0]; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train d'ajouter un |
| * noeud |
| */ |
| private boolean ajoutNoeud = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si on est en train de modifier un |
| * noeud |
| */ |
| private boolean modifNoeud = false; |
| /** |
| * Booléen d'instanciation du conteneur |
| */ |
| private boolean arbreCharge = false; |
| /** |
| * Booléen nécessaire pour l'affichage |
| * |
| */ |
| private boolean estInstancie = false; |
| /** |
| * Booléen d'évènement qui sert à savoir si les mots clés ont bien été reçu |
| */ |
| private boolean motsCleInitialises; |
| private Component livue = null; |
| MultiSelectionModel msModel = null; |
| private String cheminTemporaireAjout = null; |
| public Rafraichissable thisRafraichissable; |
| /** |
| * Constructeur sans paramètre (privé car interdit d'utilisation) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreMotsClesObservationVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètre |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreMotsClesObservationVue(ObservationMediateur om) { |
| // on crée le panel |
| super(Msg.get("projets")); |
| this.setLayout(new VerticalLayout()); |
| oMediateur = om; |
| setBorder(false); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| this.addListener(new PanelListenerAdapter() { |
| // on instancie réellement les composants au moment du rendu pour |
| // accélérer l'affichage |
| // et éviter des bugs |
| @Override |
| public void onRender(Component component) { |
| livue = oMediateur.getListeObservation(); |
| // on crée le conteneur de l'arbre |
| arbreMotsCles = new TreePanel(); |
| // on permet le drag and drop dans l'arbre |
| //arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setId("x-view-tree-keyword-obs"); |
| msModel = new MultiSelectionModel(); |
| arbreMotsCles.setSelectionModel(msModel); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode(Msg.get("projets")); |
| root.setId("racine_obs"); |
| String[] usObject = { Msg.get("projets"), "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| // on crée l'éditeur pour l'arbre |
| tfEdit = new TextField(); |
| te = new TreeEditor(arbreMotsCles, tfEdit); |
| ajouterMotCle = new Button(Msg.get("ajouter-projet")); |
| arbreMotsCles.add(te); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onClick(Node node, EventObject e) { |
| if(!arbreCharge) { |
| expand(); |
| } |
| } |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| arbreCharge = true; |
| } |
| } |
| }); |
| // on interdit le drag and drop dans l'arbre |
| arbreMotsCles.setRootVisible(true); |
| arbreMotsCles.setBorder(false); |
| // on met en forme le layout |
| add(arbreMotsCles); |
| add(ajouterMotCle); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| configDragAndDrop(); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| } |
| }); |
| } |
| /** |
| * Acesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| private ObservationMediateur getOMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Acesseur pour l'arbre des mots clés |
| * |
| * @return le panel contenant l'arbre |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreMotsCles; |
| } |
| /** |
| * Accesseur pour l'éditeur |
| * |
| * @return l'éditeur associé à l'arbre |
| */ |
| public TreeEditor getTe() { |
| return te; |
| } |
| /** |
| * Acesseur pour le TextField associé à l'éditeur |
| * |
| * @return le champ texte associé à l'éditeur |
| */ |
| public TextField getTfEdit() { |
| return tfEdit; |
| } |
| /** |
| * Ajoute les listeners nécessaires pour la gestion des évènements |
| */ |
| private void ajouterListeners() { |
| arbreMotsCles.addListener(new TreePanelListenerAdapter() { |
| // gestion du clic sur un noeud |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| boolean multi = false; |
| if(e.hasModifier()) { |
| multi = true; |
| } |
| gererClicNoeud(node,multi); |
| } |
| // gestion du clic droit sur un noeud |
| @Override |
| public void onContextMenu(TreeNode node, EventObject e) { |
| e.stopEvent(); |
| montrerContextMenuArbre(node, e, getTe()); |
| } |
| // gestion du double clic sur un noeud |
| @Override |
| public void onDblClick(TreeNode node, EventObject e) { |
| modifNoeud = true; |
| if (!node.getId().equals("racine_obs")) { |
| te.startEdit(node); |
| } |
| } |
| // gestion de la modification du texte d'un noeud |
| @Override |
| public void onTextChange(TreeNode node, String text, String oldText) { |
| if(!MotsClesUtilitaire.estUnMotCleAutorise(text)) { |
| te.startEdit(node); |
| String[] params = { MotsClesUtilitaire.getChaineCaracteresInterdits() }; |
| Window.alert(Msg.get("mot-cle-non-vide", params)); |
| return; |
| } |
| if(!MotsClesUtilitaire.estUnePositionAutorisee(node, node.getParentNode(), text)) { |
| te.startEdit(node); |
| Window.alert(Msg.get("mot-cle-existe-deja")); |
| return; |
| } |
| // on récupère les informations associées au noeud |
| TreeNode nd = node; |
| String[] usObject = new String[2]; |
| usObject[0] = text; |
| usObject[1] = ((String[]) nd.getUserObject())[1]; |
| nd.setUserObject(usObject); |
| // si c'est un nouveau noeud |
| if (ajoutNoeud) { |
| ajouterMotCleDansArbreMediateur(nd); |
| } |
| // si c'est noeud déjà existant |
| else { |
| if (modifNoeud) { |
| modifierMotCleDansArbreMediateur(nd); |
| } |
| } |
| //arbreMotsCles.disable(); |
| } |
| @Override |
| public boolean doBeforeMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| boolean ok = true; |
| if(!MotsClesUtilitaire.estUnePositionAutorisee(node, newParent, node.getText())) { |
| ok = false; |
| Window.alert(Msg.get("mot-cle-existe-deja")); |
| } |
| return ok; |
| } |
| @Override |
| public boolean onNodeDragOver(TreePanel treePanel, TreeNode target, |
| DragData dragData, String point, DragDrop source, |
| TreeNode dropNode) { |
| boolean ok = true; |
| if(dragData instanceof TreeDragData) { |
| ok = MotsClesUtilitaire.estUnePositionAutorisee(dropNode, target, dropNode.getText()); |
| } |
| return ok; |
| } |
| // gestion du déplacement d'un noeud |
| @Override |
| public void onMoveNode(Tree tree, TreeNode node, |
| TreeNode oldParent, TreeNode newParent, int index) { |
| // on notifie le médiateur et on lui passe l'arbre |
| getOMediateur().deplacerMotCleDansArbre(node, |
| getArbreMotsCles().getTree()); |
| } |
| @Override |
| public boolean doBeforeNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, |
| TreeNode dropNode, |
| DropNodeCallback dropNodeCallback) { |
| if(dragData instanceof TreeDragData) { |
| return true; |
| } |
| String idMotCle = ((String[])target.getUserObject())[1]; |
| if(oMediateur.gererDDObsSurMotCle(target, dragData)) { |
| cocherMotCle(idMotCle); |
| return true; |
| } |
| return false; |
| } |
| @Override |
| public void onNodeDrop(TreePanel treePanel, |
| TreeNode target, DragData dragData, |
| String point, DragDrop source, TreeNode dropNode) { |
| } |
| }); |
| // gestion de la validation |
| ajouterMotCle.addListener(new ButtonListenerAdapter() { |
| // lors du clic |
| @Override |
| public void onClick(Button button, EventObject e) { |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| TreeNode noeudAjout; |
| if(noeuds.length > 0) { |
| noeudAjout = noeuds[noeuds.length - 1]; |
| } else { |
| noeudAjout = arbreMotsCles.getRootNode(); |
| } |
| ajouterNoeud(noeudAjout); |
| } |
| }); |
| } |
| private void ajouterMotCleDansArbreMediateur(TreeNode nd) { |
| // on notifie le médiateur de l'ajout et on lui passe |
| // l'arbre |
| getOMediateur().ajouterMotCleDansArbre(nd, |
| getArbreMotsCles().getTree(), this); |
| // et considère l'ajout achevé |
| ajoutNoeud = false; |
| } |
| private void modifierMotCleDansArbreMediateur(TreeNode nd) { |
| // on notifie le médiateur de la modification et on lui |
| // passe l'arbre |
| getOMediateur().modifierMotCleDansArbre(nd, |
| getArbreMotsCles().getTree()); |
| // et on considère la modification achevée |
| modifNoeud = false; |
| } |
| /** |
| * Configure le drag 'n drop pour la liste |
| */ |
| private void configDragAndDrop() |
| { |
| // on fabrique la nouvelle configuration |
| // les éléments sur lesquels on fait du drag 'n drop doivent tous avoir le même ddGroup |
| arbreMotsCles.setDdGroup("ObsMotsClesGroup"); |
| //arbreMotsCles.setEnableDD(true); |
| arbreMotsCles.setEnableDrag(true); |
| arbreMotsCles.setEnableDrop(true); |
| DropTargetConfig dtc = new DropTargetConfig(); |
| dtc.setdDdGroup("ObsMotsClesGroup"); |
| } |
| /** |
| * Envoie une demande au médiateur pour obtenir l'arbre des mots clés |
| */ |
| public void obtenirArbreMotsCles() { |
| getOMediateur().obtenirArbreMotsCles(this); |
| } |
| /** |
| * Supprime un noeud de l'arbre |
| * |
| * @param n |
| * le noeud à supprimer |
| */ |
| public void supprimerNoeud(TreeNode n) { |
| // si ça n'est pas la racine (qu'on ne peut pas supprimer) |
| if (!n.getId().equals(getArbreMotsCles().getRootNode().getId())) { |
| if(Window.confirm(Msg.get("confirmer-suppression-projet"))) { |
| // on détache le noeud et on le détruit |
| n.getParentNode().removeChild(n); |
| n.destroy(); |
| // puis on en notifie le médiateur en lui passant le noeud supprimé |
| // et l'arbre |
| getOMediateur() |
| .supprimerMotCleDansArbre(n, arbreMotsCles.getTree(), this); |
| } |
| } else { |
| // si l'utilisateur tente de supprimer la racine, on l'avertit de |
| // son erreur |
| Window.alert(Msg.get("impossible-supprimer-racine")); |
| } |
| } |
| /** |
| * Ajoute un noeud dans l'arbre au parent donné |
| * |
| * @param parent |
| * le futur parent du noeud à ajouter |
| */ |
| public void ajouterNoeud(TreeNode parent) { |
| if(parent == null) { |
| parent = arbreMotsCles.getRootNode(); |
| } |
| ajoutNoeud = true; |
| TreeNode nd = MotsClesUtilitaire.ajouterNoeud(parent, false); |
| // on le concatène au parent et on étend ses enfants |
| parent.appendChild(nd); |
| parent.expand(); |
| cheminTemporaireAjout = nd.getId(); |
| te.startEdit(nd); |
| } |
| /** |
| * Fonction de gestion sur le clic sur le noeud |
| * |
| * @param node |
| */ |
| public void gererClicNoeud(TreeNode node, boolean multi) { |
| if(!arbreCharge) { |
| obtenirArbreMotsCles(); |
| } else { |
| if(multi) { |
| } |
| ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).select(node, multi); |
| oMediateur.obtenirNombreObservation(); |
| } |
| } |
| /** |
| * Parcourt l'arbre et coche les noeud qui font partie de la liste des mots |
| * clés à cocher |
| * |
| * @param motsClesIds |
| * un tableau contenant les identifiants des mots clés à cocher |
| */ |
| public void cocherMotsCles(final String[] motsClesIds) { |
| if (getArbreMotsCles() != null |
| && getArbreMotsCles().getRootNode() != null) { |
| // à partir de la racine |
| getArbreMotsCles().getRootNode().cascade( |
| new NodeTraversalCallback() { |
| // pour chaque noeud |
| @Override |
| public boolean execute(Node node) { |
| // on parcourt le tableau des mots clés |
| for (int i = 0; i < motsClesIds.length; i++) { |
| // si le mot clé fait partie des id à cocher on |
| // le coche |
| String usObject[] = (String[]) node |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| if (nodeId.equals(motsClesIds[i])) { |
| getArbreMotsCles().getNodeById(nodeId) |
| .getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
| return true; |
| } |
| } |
| if((getArbreMotsCles().getNodeById(node.getId()).getUI().getTextEl()) != null) { |
| getArbreMotsCles().getNodeById(node.getId()) |
| .getUI().getTextEl().removeClassName("x-tree-node-text-kw"); |
| } |
| // et on passe au suivant |
| return true; |
| } |
| }); |
| } |
| else { |
| motsClesEnAttente = motsClesIds ; |
| } |
| } |
| public void cocherMotCle(String motCleId) { |
| if(getArbreMotsCles().getNodeById(motCleId) != null) { |
| getArbreMotsCles().getNodeById(motCleId) |
| .getUI().getTextEl().addClassName("x-tree-node-text-kw"); |
| } |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| motsClesEnCours = ""; |
| arbreMotsCles.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreMotsCles.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données pour l'objet |
| * @param repandreRafraichissement |
| * booleen qui dit si on doit répandre l'évenement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| arbreMotsCles.enable(); |
| if(nouvelleDonnees instanceof Tree) { |
| Tree nouvelArbre = (Tree)nouvelleDonnees ; |
| // on prend sa racine et on l'attache à l'arbre des mots clés |
| Node[] rootChild = getArbreMotsCles().getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| MotsClesUtilitaire.copierFilsNoeud(nouvelArbre.getRootNode(),getArbreMotsCles().getRootNode(), false); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!arbreCharge) { |
| // on signale que oui |
| arbreCharge = true; |
| } |
| // s'il y a des mots clés en attente (lors du premier rendering) |
| if (motsCleInitialises == false && motsClesEnAttente != null) { |
| // on les coche |
| cocherMotsCles(motsClesEnAttente) ; |
| motsCleInitialises = true; |
| } |
| if(motsClesEnAttente.length > 0) { |
| cocherMotsCles(motsClesEnAttente); |
| } |
| } |
| // Si on reçoit un tableau de String (cas ou l'on séléectionne une |
| // nouvelle obs) |
| if (nouvelleDonnees instanceof String) { |
| String chaineMc = (String)nouvelleDonnees; |
| String[] motsClesIds = chaineMc.split(";"); |
| // et que l'arbre est instancié |
| if (arbreCharge) { |
| // le tableau de String contient les id des mots clés associés à |
| // l'image |
| // on coche les mots clés contenu dans le tableau |
| cocherMotsCles(motsClesIds); |
| } |
| // si l'arbre n'est pas encore instancié on met les mots clés en |
| // attente |
| else { |
| motsClesEnAttente = motsClesIds; |
| } |
| } |
| // reception d'un nouvel identifiant de mot clé |
| if(nouvelleDonnees instanceof Integer) { |
| if(cheminTemporaireAjout != null) { |
| String id = ((Integer)(nouvelleDonnees)).toString(); |
| TreeNode noeudEnAjout = arbreMotsCles.getNodeById(cheminTemporaireAjout); |
| String[] userObj = {noeudEnAjout.getText(), id}; |
| noeudEnAjout.setUserObject(userObj); |
| cheminTemporaireAjout = null; |
| } |
| } |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreMotsCles.collapseAll(); |
| arbreMotsCles.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode(Msg.get("projets")); |
| root.setId("racine_obs"); |
| String[] usObject = { Msg.get("projets"), "racine_obs" }; |
| root.setUserObject(usObject); |
| root.setExpandable(true); |
| arbreMotsCles.setRootNode(root); |
| arbreMotsCles.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| obtenirArbreMotsCles() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| motsClesEnCours = ""; |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| // TODO Auto-generated method stub |
| return false; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| // TODO Auto-generated method stub |
| return null; |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String val = ""; |
| TreeNode[] noeuds = ((MultiSelectionModel)arbreMotsCles.getSelectionModel()).getSelectedNodes(); |
| for(int i = 0; i< noeuds.length ; i++) { |
| if(noeuds[i].getDepth() > 0) { |
| String usObject[] = (String[]) noeuds[i] |
| .getUserObject(); |
| String nodeId = usObject[1]; |
| val += ";"+nodeId; |
| } |
| } |
| val = val.replaceFirst(";", ""); |
| String[] valeursFiltres = {"id_mots_cles", val}; |
| return valeursFiltres; |
| } |
| @Override |
| public void valider() { |
| // TODO Auto-generated method stub |
| } |
| public void montrerContextMenuArbre(final TreeNode n, EventObject e, |
| TreeEditor te) { |
| Menu mn = new Menu(); |
| final com.gwtext.client.widgets.menu.Item ajoutN = new Item( |
| Msg.get("ajouter-projet")); |
| final com.gwtext.client.widgets.menu.Item suppN = new Item( |
| Msg.get("supprimer-projet")); |
| mn.addItem(ajoutN); |
| mn.addItem(suppN); |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| if (item.equals(suppN)) { |
| supprimerNoeud(n); |
| } |
| if (item.equals(ajoutN)) { |
| ajouterNoeud(n); |
| } |
| } |
| }); |
| mn.showAt(e.getXY()); |
| } |
| @Override |
| public void viderFiltre() { |
| arbreMotsCles.getSelectionModel().clearSelections(); |
| motsClesEnCours = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/filtres/RechercheLibreVue.java |
|---|
| New file |
| 0,0 → 1,117 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.gwtext.client.core.EventCallback; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.form.TextField; |
| public class RechercheLibreVue extends Panel implements Filtrable { |
| private ObservationMediateur oMediateur = null; |
| private TextField champRecherche = null; |
| private static String titrePanneau = Msg.get("recherche-libre"); |
| private String valeurRecherchee= ""; |
| private Button boutonRechercher = null; |
| private boolean estModifie = true; |
| private final int KEY_ENTER = 13; |
| public RechercheLibreVue(ObservationMediateur om) { |
| super(titrePanneau); |
| oMediateur = om; |
| champRecherche = new TextField(); |
| champRecherche.setWidth("90%"); |
| boutonRechercher = new Button(Msg.get("rechercher")); |
| boutonRechercher.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| champRecherche.addKeyPressListener(new EventCallback() { |
| @Override |
| public void execute(EventObject e) { |
| switch(e.getKey()) { |
| case KEY_ENTER: |
| valider(); |
| break; |
| } |
| } |
| }); |
| add(champRecherche); |
| add(boutonRechercher); |
| setCollapsible(true); |
| setTitleCollapse(true); |
| setPaddings(5); |
| } |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return estModifie; |
| } |
| @Override |
| public String renvoyerNomFiltre() { |
| return Msg.get("recherche-libre"); |
| } |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String nom = "recherche"; |
| if(champRecherche.getValueAsString() != null && !champRecherche.getValueAsString().trim().equals("")) { |
| valeurRecherchee = champRecherche.getValueAsString(); |
| } else { |
| valeurRecherchee = ""; |
| } |
| String[] valeurs = {nom,valeurRecherchee}; |
| return valeurs; |
| } |
| @Override |
| public void valider() { |
| if(champRecherche.getValueAsString() != null && champRecherche.getValueAsString() != valeurRecherchee) { |
| estModifie = true; |
| oMediateur.obtenirNombreObservation(); |
| } else { |
| estModifie = false; |
| } |
| } |
| public void raz() { |
| if(champRecherche.isCreated()) { |
| champRecherche.reset(); |
| valeurRecherchee = ""; |
| } |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| valeurRecherchee = ""; |
| } |
| } |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/filtres/ArbreEntiteGeographiqueObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,630 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.EntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.ListeEntiteGeographiqueObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| /** |
| * Arbre Filtrant sur les entites geographiques |
| * |
| * |
| * @author aurelien + david |
| * |
| */ |
| public class ArbreEntiteGeographiqueObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String entitesGeographiquesEncours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreEntitesGeographiques = null; |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreEntiteGeographiqueObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreEntiteGeographiqueObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super(Msg.get("localites")); |
| this.observationMediateur = obs; |
| arbreEntitesGeographiques = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| this.addListener(new PanelListenerAdapter() { |
| // on instancie réellement les composants au moment du rendu pour |
| // accélérer l'affichage |
| // et éviter des bugs |
| @Override |
| public void onRender(Component component) { |
| // on interdit le drag and drop dans l'arbre |
| arbreEntitesGeographiques.setEnableDD(false); |
| arbreEntitesGeographiques.setId("x-view-tree-filter-entity"); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode(Msg.get("localites")); |
| root.setId("racine_entite"); |
| String[] usObject = { Msg.get("localites") }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.setRootVisible(true); |
| arbreEntitesGeographiques.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreEntitesGeographiques); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreEntitesGeographiques.addListener(new TreePanelListenerAdapter() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| nomFiltre = "" ; |
| entitesGeographiquesEncours = "" ; |
| String[] filtresStr = {"pays","departement","localite","lieudit","station"}; |
| int profNoeud = node.getDepth(); |
| if(profNoeud == 0) { |
| if(!arbreCharge) |
| { |
| arbreEntitesGeographiques.getRootNode().expand(); |
| } |
| else |
| { |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| } else { |
| Node noeud = (Node)node; |
| for(int i = profNoeud - 1; i >= 0; i--) { |
| nomFiltre += filtresStr[i]+","; |
| entitesGeographiquesEncours += ((String[])noeud.getUserObject())[0]+","; |
| noeud = noeud.getParentNode(); |
| } |
| nomFiltre.replaceAll(",$", ""); |
| entitesGeographiquesEncours.replaceAll(",$", ""); |
| } |
| filtreModifie = true ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| entitesGeographiquesEncours = ""; |
| arbreEntitesGeographiques.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreEntitesGeographiques.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirListeEntiteGeographique() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeEntiteGeographiqueObservation) { |
| ListeEntiteGeographiqueObservation data = (ListeEntiteGeographiqueObservation) nouvelleDonnees ; |
| // on crée un arbre vide |
| Tree nouvelArbre = new Tree() ; |
| TreeNode root = new TreeNode(); |
| root.setId("racine_entite"); |
| root.setText(Msg.get("localites")); |
| String[] usObjRoot = { Msg.get("localites") }; |
| root.setUserObject(usObjRoot); |
| nouvelArbre.setRootNode(root); |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().eachChild(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| EntiteGeographiqueObservation ent=data.get(it.next()); |
| creerHierarchieNoeud(nouvelArbre ,root, ent); |
| doLayout(); |
| } |
| copierFilsNoeud(root, arbreEntitesGeographiques.getRootNode()); |
| arbreEntitesGeographiques.getRootNode().sort(comparerNoeuds()) ; |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!estInstancie) { |
| // on signale que oui |
| estInstancie = true; |
| } |
| // l'état du filtre est réinitialisé |
| filtreModifie = false; |
| //show() ; |
| arbreEntitesGeographiques.doLayout(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // Cas d'ajout unitaire d'une observation |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation obs = (Observation)nouvelleDonnees ; |
| EntiteGeographiqueObservation ent = new EntiteGeographiqueObservation(obs.getIdentifiantLocalite(),obs.getLocalite(),obs.getLieudit(),obs.getStation()); |
| ent.setPays(obs.getPays()); |
| creerHierarchieNoeud(arbreEntitesGeographiques.getTree(), arbreEntitesGeographiques.getRootNode(), ent); |
| doLayout(); |
| arbreEntitesGeographiques.doLayout() ; |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreEntitesGeographiques; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return Msg.get("localites"); |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String valeursFiltrees[] = {nomFiltre, entitesGeographiquesEncours } ; |
| return valeursFiltrees; |
| } |
| /** |
| * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
| * copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
| * |
| * @param ndPereOriginal |
| * le père des noeuds de l'arbre original |
| * @param ndPereCopie |
| * le père qui va recevoir les copies |
| */ |
| private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) { |
| if (ndPereCopie != null && ndPereOriginal != null) { |
| Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
| for (int i = 0; i < ndNodeFils.length; i++) { |
| String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
| TreeNode child = new TreeNode(usObj[0]); |
| child.setUserObject(usObj); |
| child.setId(""+usObj[1]); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| /** |
| * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| if(o1.getText().equals(Msg.get("inconnue"))) { |
| return -1 ; |
| } |
| if(o2.getText().equals(Msg.get("inconnue"))) { |
| return 1 ; |
| } |
| if(o1.getDepth() == 1 && o2.getDepth() == 1) |
| { |
| String l1 = o1.getText() ; |
| String l2 = o2.getText() ; |
| if(l1.length() == 1) { |
| l1 = "0"+l1; |
| } |
| if(l2.length() == 1) { |
| l2 = "0"+l2; |
| } |
| Integer n1 = 0; |
| Integer n2 = 0; |
| try{ |
| n1 = Integer.parseInt(l1) ; |
| n2 = Integer.parseInt(l2) ; |
| } catch(NumberFormatException ne) { |
| n1 = 0; |
| n2 = 0; |
| } |
| return n1.compareTo(n2) ; |
| } |
| else |
| { |
| String n1 = o1.getId() ; |
| String n2 = o2.getId() ; |
| return n1.compareToIgnoreCase(n2); |
| } |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreEntitesGeographiques.collapseAll(); |
| arbreEntitesGeographiques.clear() ; |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode(Msg.get("localites")); |
| root.setId("racine_entite"); |
| String[] usObject = { Msg.get("localites") }; |
| root.setUserObject(usObject); |
| arbreEntitesGeographiques.setRootNode(root); |
| arbreEntitesGeographiques.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| entitesGeographiquesEncours = ""; |
| } |
| private TreeNode creerNoeud(String id, String texte) { |
| TreeNode nouveauNoeud = new TreeNode(); |
| nouveauNoeud.setId(""+(id)); |
| nouveauNoeud.setText(texte); |
| String[] usObj = {texte,id+""}; |
| nouveauNoeud.setUserObject(usObj); |
| return nouveauNoeud; |
| } |
| /** |
| * |
| * @param arbre l'arbre dans lequel on recherche s'il faut créer les noeuds |
| * @param root le noeud racine auquel on concatène la hierarchie crée |
| * @param ent l'entité géographique qui doit être décomposée en arborescence |
| * @return |
| */ |
| private void creerHierarchieNoeud(Tree arbre, TreeNode root, EntiteGeographiqueObservation ent) { |
| String id_zone_geo=null; |
| String zone_geo=null; |
| String lieuDit=null; |
| String station=null; |
| String id_pays = ent.getPays(); |
| // TODO creer une fonction plus efficace lors du passage au multi reférentiel |
| id_zone_geo = Util.convertirChaineZoneGeoVersDepartement(ent.getIdZoneGeo()); |
| id_zone_geo = id_zone_geo.replaceAll("\"", ""); |
| id_zone_geo = id_zone_geo.replace('\\',' '); |
| id_zone_geo = id_zone_geo.trim(); |
| zone_geo = ent.getZoneGeo(); |
| lieuDit = ent.getLieuDit(); |
| station = ent.getStation(); |
| if(id_pays.equals(null) || (id_pays.trim()).isEmpty()) { |
| id_pays=Msg.get("inconnue") ; |
| } |
| if(id_zone_geo.contains("000null") || id_zone_geo.equals(null) || (id_zone_geo.trim()).equals("")) { |
| id_zone_geo=Msg.get("inconnue") ; |
| } else { |
| if(ent.getIdZoneGeo().contains("INSEE-C:") && ent.getIdZoneGeo().length() > 10) { |
| id_pays = "FR"; |
| } |
| } |
| if(zone_geo.contains("000null") || zone_geo.equals(null) || (zone_geo.trim().equals(""))) { |
| zone_geo=Msg.get("inconnue") ; |
| } |
| if(lieuDit.contains("000null") || lieuDit.equals(null) || (lieuDit.trim().equals(""))) { |
| lieuDit=Msg.get("inconnue") ; |
| } |
| if(station.contains("000null") || station.equals(null) || (station.trim().equals(""))) { |
| station=Msg.get("inconnue") ; |
| } |
| String[] idLocalites = {id_pays, id_zone_geo, zone_geo, lieuDit, station}; |
| Node noeudMemeId = null; |
| String idNoeud = ""; |
| String locNiveau = ""; |
| Node noeudParent = root; |
| for(int i = 0; i < idLocalites.length; i++) { |
| // Recherche des noeuds correspondant à chacun des niveaux de la hierarchie |
| locNiveau = idLocalites[i]; |
| idNoeud += idLocalites[i]; |
| noeudMemeId = arbre.getNodeById(idNoeud); |
| // Si le noeud n'existe pas on le crée |
| if(noeudMemeId == null) { |
| noeudMemeId = creerNoeud(idNoeud, locNiveau); |
| noeudParent.appendChild(noeudMemeId) ; |
| } |
| noeudParent = noeudMemeId; |
| } |
| root.sort(comparerNoeuds()) ; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreEntitesGeographiques.getSelectionModel().clearSelections(); |
| entitesGeographiquesEncours =""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreEntitesGeographiques.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreEntitesGeographiques.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreEntitesGeographiques.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("pays")) { |
| profondeur = 1; |
| } |
| if(nom.equals("departement")) { |
| profondeur = 2; |
| } |
| if(nom.equals("localite")) { |
| profondeur = 3; |
| } |
| if(nom.equals("lieudit")) { |
| profondeur = 4; |
| } |
| if(nom.equals("station")) { |
| profondeur = 5; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/filtres/ArbreDateObservationFiltreVue.java |
|---|
| New file |
| 0,0 → 1,682 |
| package org.tela_botanica.client.vues.observation.filtres; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.DateObservation; |
| import org.tela_botanica.client.modeles.objets.ListeDate; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.gwtext.client.data.Node; |
| import com.gwtext.client.data.NodeTraversalCallback; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.Component; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.PanelListenerAdapter; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| import com.gwtext.client.widgets.tree.TreePanel; |
| import com.gwtext.client.widgets.tree.event.TreeNodeListenerAdapter; |
| import com.gwtext.client.widgets.tree.event.TreePanelListenerAdapter; |
| import com.gwtext.client.core.EventObject; |
| /** |
| * fenêtre de recherche affichant l'arbre des mots clés en lecture et un bouton |
| * cliquable |
| * |
| * @author aurelien |
| * |
| */ |
| public class ArbreDateObservationFiltreVue extends Panel implements Rafraichissable, |
| Filtrable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * Les localites en cours |
| */ |
| private String donneesDateEnCours = ""; |
| /** |
| * Le treepanel qui affiche l'arbre |
| */ |
| private TreePanel arbreDonneesDates = null; |
| /** |
| * La structure de donnees qui stocke l'arbre. Utilisee a ce niveau car trop liee a la vue |
| */ |
| /** |
| * booléen d'initialisation |
| */ |
| private boolean estInstancie = false; |
| /** |
| * booléen d'etat |
| */ |
| private boolean filtreModifie = false; |
| private boolean arbreCharge = false ; |
| private String nomFiltre = "" ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ArbreDateObservationFiltreVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec paramètres |
| * |
| * @param im |
| * le médiateur à associer |
| */ |
| public ArbreDateObservationFiltreVue(ObservationMediateur obs) { |
| // on crée le panel |
| super(Msg.get("dates")); |
| this.observationMediateur = obs; |
| arbreDonneesDates = new TreePanel(); |
| this.setPaddings(5); |
| this.setCollapsible(true); |
| this.setAutoScroll(true); |
| // on ajoute les listeners |
| ajouterListenersPanel(); |
| estInstancie = false; |
| } |
| /** |
| * Ajoute les listeners pour le rendu du panel |
| */ |
| private void ajouterListenersPanel() { |
| this.addListener(new PanelListenerAdapter() { |
| // on instancie réellement les composants au moment du rendu pour |
| // accélérer l'affichage |
| // et éviter des bugs |
| @Override |
| public void onRender(Component component) { |
| // on interdit le drag and drop dans l'arbre |
| arbreDonneesDates.setEnableDD(false); |
| arbreDonneesDates.setId("x-view-tree-filter-date"); |
| arbreDonneesDates.setBorder(false); |
| // on crée une racine pour l'arbre |
| TreeNode root = new TreeNode(Msg.get("dates")); |
| root.setId("racine_date"); |
| String[] usObject = { Msg.get("dates"), "Dates", "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.setRootVisible(true); |
| arbreDonneesDates.setBorder(false); |
| root.setExpandable(true) ; |
| add(arbreDonneesDates); |
| // on ajoute les listeners d'évenements |
| ajouterListeners(); |
| // enfin on considère le composant comme instancié |
| estInstancie = true; |
| } |
| }); |
| } |
| /** |
| * ajoute les listeners pour les boutons et le cochage des entites |
| */ |
| private void ajouterListeners() { |
| arbreDonneesDates.addListener(new TreePanelListenerAdapter() { |
| @Override |
| public void onClick(TreeNode node, EventObject e) { |
| gererClicNoeud(node); |
| } |
| }) ; |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| private void gererClicNoeud(TreeNode node) { |
| mettreAJourValeurEnCours(node); |
| observationMediateur.obtenirNombreObservation() ; |
| } |
| private void mettreAJourValeurEnCours(TreeNode node) { |
| nomFiltre = "" ; |
| donneesDateEnCours = "" ; |
| String nomPere = "" ; |
| String nomGrandPere = "" ; |
| switch(node.getDepth()) |
| { |
| case 0: |
| if(arbreCharge) { |
| nomFiltre = ""; |
| donneesDateEnCours = ""; |
| } |
| break; |
| case 3: nomFiltre += "annee,mois,jour"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| nomGrandPere = ((String[])node.getParentNode().getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomGrandPere+","+nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 2: nomFiltre += "annee,mois"; |
| nomPere = ((String[])node.getParentNode().getUserObject())[1] ; |
| donneesDateEnCours += nomPere+","+((String[])node.getUserObject())[1] ; |
| break; |
| case 1: nomFiltre += "annee"; |
| donneesDateEnCours += ((String[])node.getUserObject())[1] ; |
| break; |
| default: |
| break; |
| } |
| filtreModifie = true ; |
| } |
| public void initialiser() { |
| arbreCharge = false ; |
| donneesDateEnCours = ""; |
| arbreDonneesDates.collapseAll(); |
| // on vide l'ancien arbre |
| Node[] rootChild = arbreDonneesDates.getRootNode().getChildNodes(); |
| for (int i = 0; i < rootChild.length; i++) { |
| rootChild[i].remove(); |
| } |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if (nouvelleDonnees instanceof ListeDate) { |
| String annee=null; |
| String mois=null; |
| String jour=null; |
| ListeDate data = (ListeDate) nouvelleDonnees ; |
| // on crée un arbre vide |
| TreeNode root = new TreeNode(); |
| root.setId("racine_date"); |
| root.setText(Msg.get("dates")); |
| String[] usObjRoot = { Msg.get("dates"), Msg.get("dates"), "racine_date"}; |
| root.setUserObject(usObjRoot); |
| Tree nouvelArbre = new Tree(); |
| nouvelArbre.setRootNode(root); |
| // on la parse et on récupère les informations qui nous interessent |
| for (Iterator<String> it= data.keySet().iterator(); it.hasNext();) { |
| DateObservation ent=data.get(it.next()); |
| annee= ent.getAnnee() ; |
| mois= ent.getMois() ; |
| String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ; |
| jour= ent.getJour() ; |
| if(annee.contains("0000")) { |
| annee=Msg.get("inconnue") ; |
| } |
| if(jour.contains("00")) { |
| jour=Msg.get("inconnue") ; |
| } |
| Node noeudMemeAnnee = nouvelArbre.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = nouvelArbre.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = nouvelArbre.getNodeById(""+(annee+mois+jour)); |
| if(noeudMemeJour != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| noeudMemeMois.appendChild(node_jour) ; |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(""+annee); |
| node_annee.setText(annee); |
| root.appendChild(node_annee) ; |
| String[] usObj = {annee, annee, annee}; |
| node_annee.setUserObject(usObj); |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| node_annee.appendChild(node_mois) ; |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| node_mois.appendChild(node_jour) ; |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| } |
| } |
| // on trie |
| root.sort(comparerNoeuds()) ; |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().eachChild(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| node.remove(); |
| return true; |
| } |
| }); |
| // et on recopie le nouvel arbre |
| copierFilsNoeud(nouvelArbre.getRootNode(), arbreDonneesDates |
| .getRootNode()); |
| // si l'arbre n'était pas encore considéré comme instancié |
| if (!estInstancie) { |
| // on signale que oui |
| estInstancie = true; |
| } |
| // l'état du filtre est réinitialisé |
| filtreModifie = false; |
| //show() ; |
| doLayout(); |
| } |
| if(nouvelleDonnees instanceof Observation) |
| { |
| // si l'arbre n'est pas encore chargé, on ne tient pas compte de l'ajout |
| // l'arbre complet sera de toute façon renvoyé plus tard lors du premier chargement |
| // de l'arbre |
| if(!arbreCharge) { |
| return; |
| } |
| Observation ent = (Observation)nouvelleDonnees ; |
| String dateSpl[] = ent.getDate().split("/") ; |
| String annee= dateSpl[2]; |
| String mois= dateSpl[1]; |
| String jour= dateSpl[0]; |
| String moisLettre = Util.renvoyerMois(Integer.parseInt(mois)) ; |
| Node root = arbreDonneesDates.getRootNode() ; |
| if(annee.contains("0000") || annee.equals(null)) { |
| annee=Msg.get("inconnue") ; |
| } |
| if(jour.contains("00") || jour.equals(null)) { |
| jour=Msg.get("inconnue") ; |
| } |
| Node noeudMemeAnnee = arbreDonneesDates.getNodeById(""+annee); |
| // si la région existe déjà |
| if(noeudMemeAnnee != null) |
| { |
| // on teste si la localité existe |
| Node noeudMemeMois = arbreDonneesDates.getNodeById(""+(annee+mois)); |
| if(noeudMemeMois != null) |
| { |
| // enfin on teste si le lieu dit existe |
| Node noeudMemeJour = arbreDonneesDates.getNodeById(""+(annee+mois+jour)); |
| if(noeudMemeJour != null) |
| { |
| // tous les noeuds existent déjà, normalement ça ne devrait pas arriver |
| } |
| else |
| { |
| // enfin on ne crée que le noeud du lieu dit |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj); |
| noeudMemeMois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj); |
| noeudMemeAnnee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj2 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj2); |
| node_mois.appendChild(node_jour) ; |
| root.sort(comparerNoeuds()) ; |
| } |
| } |
| else |
| { |
| TreeNode node_annee = new TreeNode(); |
| node_annee.setId(""+annee); |
| node_annee.setText(annee); |
| String[] usObj = {annee,annee,annee}; |
| node_annee.setUserObject(usObj); |
| root.appendChild(node_annee) ; |
| TreeNode node_mois = new TreeNode(); |
| node_mois.setId(""+(annee+mois)); |
| node_mois.setText(moisLettre); |
| String[] usObj2 = {moisLettre,mois,annee+mois}; |
| node_mois.setUserObject(usObj2); |
| node_annee.appendChild(node_mois) ; |
| TreeNode node_jour = new TreeNode(); |
| node_jour.setId(""+(annee+mois+jour)); |
| node_jour.setText(jour); |
| String[] usObj3 = {jour,jour,annee+mois+jour}; |
| node_jour.setUserObject(usObj3); |
| node_mois.appendChild(node_jour) ; |
| // TODO : améliorer la compararaison des noeuds |
| root.sort(comparerNoeuds()) ; |
| } |
| arbreDonneesDates.doLayout() ; |
| } |
| } |
| /** |
| * Accesseur pour le panneau contenant l'arbre |
| * |
| * @return le panneau de l'arbre des mots clés |
| */ |
| public TreePanel getArbreMotsCles() { |
| return arbreDonneesDates; |
| } |
| /** |
| * Méthode héritée de Filtrable renvoie le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return Msg.get("dates"); |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| valider(); |
| String valeursFiltrees[] = {nomFiltre, donneesDateEnCours } ; |
| return valeursFiltrees; |
| } |
| /** |
| * Fonction récursive qui prend deux noeuds d'arbre en paramètre et crée un |
| * copie du sous arbre du premier noeud, qu'elle concatène au deuxième |
| * |
| * @param ndPereOriginal |
| * le père des noeuds de l'arbre original |
| * @param ndPereCopie |
| * le père qui va recevoir les copies |
| */ |
| private void copierFilsNoeud(Node ndPereOriginal, TreeNode ndPereCopie) { |
| if (ndPereCopie != null && ndPereOriginal != null) { |
| Node[] ndNodeFils = ndPereOriginal.getChildNodes(); |
| for (int i = 0; i < ndNodeFils.length; i++) { |
| String[] usObj = (String[]) ndNodeFils[i].getUserObject(); |
| TreeNode child = new TreeNode(usObj[0]); |
| child.setUserObject(usObj); |
| child.setId(""+usObj[2]); |
| ndPereCopie.appendChild(child); |
| if (!ndNodeFils[i].isLeaf()) { |
| copierFilsNoeud(ndNodeFils[i], child); |
| } |
| } |
| } |
| } |
| /** |
| * Méthode héritée de Filtrable Renvoie l'état du filtre (modifié ou non) |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| @Override |
| public void valider() { |
| if (estInstancie) { |
| } |
| } |
| public Comparator<TreeNode> comparerNoeuds() |
| { |
| return new Comparator<TreeNode>() { |
| @Override |
| public int compare(TreeNode o1, TreeNode o2) { |
| String n1 = ((String[])o1.getUserObject())[1] ; |
| String n2 = ((String[])o2.getUserObject())[1] ; |
| return n1.compareTo(n2) ; |
| } |
| } ; |
| } |
| public void raz() { |
| arbreCharge = false ; |
| arbreDonneesDates.collapseAll(); |
| arbreDonneesDates.clear(); |
| TreeNode root = new TreeNode(Msg.get("dates")); |
| root.setId("racine_date"); |
| String[] usObject = { Msg.get("dates"), Msg.get("dates"), "racine_date" }; |
| root.setUserObject(usObject); |
| arbreDonneesDates.setRootNode(root); |
| arbreDonneesDates.getRootNode().addListener(new TreeNodeListenerAdapter() { |
| @Override |
| public void onExpand(Node node) { |
| if(!arbreCharge) |
| { |
| observationMediateur.obtenirDatesObservation() ; |
| arbreCharge = true ; |
| } |
| } |
| }) ; |
| this.doLayout() ; |
| donneesDateEnCours = ""; |
| } |
| @Override |
| public void viderFiltre() { |
| arbreDonneesDates.getSelectionModel().clearSelections(); |
| donneesDateEnCours = ""; |
| } |
| public void viderFiltre(String nom) { |
| final int profondeur = calculerProfondeurPourNomFiltre(nom); |
| // on vide tous les noeuds |
| arbreDonneesDates.getRootNode().cascade(new NodeTraversalCallback() { |
| @Override |
| public boolean execute(Node node) { |
| boolean continuer = true; |
| TreeNode noeudArbreEncours = (TreeNode)node; |
| if(arbreDonneesDates.getSelectionModel().isSelected(noeudArbreEncours)) { |
| int profondeurDepart = noeudArbreEncours.getDepth(); |
| for(int profondeurNoeudArbreEncours = profondeurDepart; profondeurNoeudArbreEncours >= profondeur; profondeurNoeudArbreEncours--) { |
| noeudArbreEncours = (TreeNode)noeudArbreEncours.getParentNode(); |
| } |
| arbreDonneesDates.getSelectionModel().select(noeudArbreEncours); |
| mettreAJourValeurEnCours(noeudArbreEncours); |
| continuer = false; |
| } |
| return continuer; |
| } |
| }); |
| } |
| private int calculerProfondeurPourNomFiltre(String nom) { |
| int profondeur = 0; |
| if(nom.equals("annee")) { |
| profondeur = 1; |
| } |
| if(nom.equals("mois")) { |
| profondeur = 2; |
| } |
| if(nom.equals("jour")) { |
| profondeur = 3; |
| } |
| return profondeur; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/indicateurs/LienExterneVue.java |
|---|
| New file |
| 0,0 → 1,85 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.widgets.Panel; |
| public class LienExterneVue extends Panel implements Rafraichissable { |
| private String refTax = ""; |
| private String numTax = ""; |
| private String efloreBaseUrl = ""; |
| private Label titreLien = new Label(Msg.get("voir-fiche-eflore")); |
| public LienExterneVue(ObservationMediateur om) { |
| refTax = verifierEtFormaterReferentiel(om.getRefTaxSelectionne().getCode()); |
| efloreBaseUrl = Configuration.getLienEfloreBaseUrl(); |
| titreLien.setVisible(false); |
| setBorder(false); |
| titreLien.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(!numTax.trim().equals("")) { |
| Window.open("http://"+efloreBaseUrl+"/"+refTax+"-nn-"+numTax,"",""); |
| } |
| } |
| }); |
| titreLien.setStyleName("lien_actif"); |
| add(titreLien); |
| } |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| String[] nouvellesDonnees = (String[]) nouvelleDonnees; |
| String nouveauNumTax = nouvellesDonnees[0]; |
| String codeRef = nouvellesDonnees[1]; |
| if(nouveauNumTax.trim().equals("") || codeRef.trim().equals("autre") || nouveauNumTax.trim().equals("0") || codeRef.trim().equals("")) { |
| titreLien.setVisible(false); |
| } else { |
| if(!titreLien.isVisible()) { |
| titreLien.setVisible(true); |
| } |
| numTax = nouveauNumTax; |
| refTax = verifierEtFormaterReferentiel(codeRef); |
| } |
| } |
| public String verifierEtFormaterReferentiel(String refTax) { |
| // Sert simplement à exclure les vieux formats de référentiel |
| // du genre bdtfx:v2.00 ou bien bdnff.v1_01 etc... |
| // TODO: nettoyer également la base de données |
| String retour = refTax; |
| if(retour != null && !retour.isEmpty()) { |
| if (retour.contains(":")) { |
| retour = retour.split(":")[0]; |
| } |
| if(retour.contains(".")) { |
| retour = retour.split(".")[0]; |
| } |
| } |
| return retour; |
| } |
| } |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/indicateurs/MiniZoomImageVue.java |
|---|
| New file |
| 0,0 → 1,608 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.objets.ImageCarnet; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.LoadEvent; |
| import com.google.gwt.event.dom.client.LoadHandler; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.core.AnimationConfig; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.core.Ext; |
| import com.gwtext.client.core.ExtElement; |
| import com.gwtext.client.core.RegionPosition; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| import com.gwtext.client.widgets.layout.BorderLayout; |
| import com.gwtext.client.widgets.layout.BorderLayoutData; |
| import com.gwtext.client.widgets.menu.BaseItem; |
| import com.gwtext.client.widgets.menu.Item; |
| import com.gwtext.client.widgets.menu.Menu; |
| import com.gwtext.client.widgets.menu.event.MenuListenerAdapter; |
| /** |
| * Panneau d'affichage d'une image avec des boutons précdents et suivant |
| * |
| * @author aurelien |
| * |
| */ |
| public class MiniZoomImageVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé à la vue |
| */ |
| private ObservationMediateur oMediateur = null; |
| /** |
| * Le titre du panneau |
| */ |
| private static String titrePanneau = Msg.get("images-liees"); |
| /** |
| * Panneau conteneur pour l'image |
| */ |
| private Panel imageConteneur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(""); |
| /** |
| * Bouton précédent |
| */ |
| private final com.google.gwt.user.client.ui.Button prev = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Bouton suivant |
| */ |
| private final com.google.gwt.user.client.ui.Button suiv = new com.google.gwt.user.client.ui.Button(); |
| /** |
| * Taille originale Y de l'image |
| */ |
| private int imageHeight = 0; |
| /** |
| * Taille originale X de l'image |
| */ |
| private int imageWidth = 0; |
| /** |
| * Identifiant de l'image |
| */ |
| private String idImage = "0" ; |
| private String[] infosImages[] = null ; |
| private int index = 0 ; |
| /** |
| * true pour animer les transitions |
| */ |
| private boolean animerTransition = false; |
| /** |
| * Détermine la durée de la transition |
| */ |
| private float dureeAnimation = (float) 0.15; |
| /** |
| * Booleen d'initalisation général |
| */ |
| private boolean initialise = false; |
| /** |
| * Booleen d'initalisation du conteneur d'image |
| */ |
| private boolean conteneurInitialise = false; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ; |
| Image imgAgrandie = null; |
| private HTML htmlVide = new HTML(); |
| /** |
| * Constructeur sans argument (privé car ne doit être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MiniZoomImageVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * |
| * @param im |
| * le médiateur à associer à la vue |
| */ |
| public MiniZoomImageVue(ObservationMediateur im) { |
| super(titrePanneau); |
| setId("x-view-mini-zoom-panel"); |
| // on associe le médiateur |
| oMediateur = im; |
| prev.setStylePrimaryName("x-view-zoom-button-p"); |
| suiv.setStylePrimaryName("x-view-zoom-button-s"); |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| imgZoom.setConstrain(true); |
| // on crée une image qui gère le double clic et la roulette de la souris |
| image = new Image() { |
| @Override |
| public void onBrowserEvent(Event event) { |
| // lors d'un déplacement de la roulette |
| if (Event.ONMOUSEWHEEL == DOM.eventGetType(event)) { |
| // on simule un clic sur le bouton précédent |
| if (event.getMouseWheelVelocityY() >= 1) { |
| prev.click(); |
| } |
| // ou suivant |
| if (event.getMouseWheelVelocityY() <= -1) { |
| suiv.click(); |
| } |
| } |
| if(Event.ONCONTEXTMENU == DOM.eventGetType(event)) { |
| event.preventDefault() ; |
| int[] xy = {event.getClientX(),event.getClientY()} ; |
| afficherMenu(xy) ; |
| } |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| if(imgZoom.isVisible()) { |
| imgZoom.hide(); |
| } else { |
| afficherPanneauAgrandi(); |
| } |
| } |
| } |
| }; |
| image.setPixelSize(150, 150); |
| infosImages = new String[0][0] ; |
| this.setHeader(true); |
| imageConteneur = new Panel() ; |
| imageConteneur.setBorder(false); |
| imageConteneur.add(image); |
| imageConteneur.setId("x-view-mini-zoom-img"); |
| imageConteneur.add(htmlVide); |
| // il n'existe pas de méthode pour ajouter un listener pour le double |
| // clic sur une image |
| // alors on lui dit manuellement de capter l'évènement double clic |
| image.sinkEvents(Event.ONDBLCLICK); |
| image.sinkEvents(Event.ONMOUSEWHEEL); |
| image.sinkEvents(Event.ONCONTEXTMENU) ; |
| this.setLayout(new BorderLayout()); |
| prev.setWidth("15%"); |
| suiv.setWidth("15%"); |
| this.add(prev, new BorderLayoutData(RegionPosition.WEST)); |
| this.add(imageConteneur, new BorderLayoutData(RegionPosition.CENTER)); |
| this.add(suiv, new BorderLayoutData(RegionPosition.EAST)); |
| imageConteneur.setMaskDisabled(true); |
| this.setBorder(false); |
| conteneurInitialise = true; |
| initialise = true; |
| image.setVisible(false); |
| afficherImageSinonAfficherMessage(false); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Méthode héritée de l'interface rafraichissable |
| * |
| * @param nouvelleDonnees |
| * les nouvelles données |
| * @param repandreRafraichissement |
| * le booleen qui dit si on doit répnadre l'évènement |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRafraichissement) { |
| // si on reçoit une string |
| if (nouvelleDonnees instanceof String[][] && initialise |
| && conteneurInitialise && ((String[][])nouvelleDonnees).length != 0) { |
| infosImages = (String[][]) nouvelleDonnees; |
| index = 0 ; |
| afficherImageSinonAfficherMessage(true); |
| afficherImage() ; |
| } else { |
| afficherImageSinonAfficherMessage(false); |
| } |
| } |
| public void afficherImage() |
| { |
| // c'est l'url de l'image qu'on associe à la vue |
| if(infosImages != null && infosImages.length != 0) |
| { |
| setTitle(titrePanneau+" "+(index+1)+" / "+infosImages.length); |
| getImage().setUrl(getUrlMiniature(index)); |
| imageWidth = Integer.parseInt(infosImages[index][1]); |
| imageHeight = Integer.parseInt(infosImages[index][2]); |
| verifierEtRetaillerImage(); |
| activerPanneau(true); |
| } |
| if(infosImages != null && infosImages.length > 1) { |
| prev.setEnabled(true); |
| suiv.setEnabled(true); |
| } else { |
| prev.setEnabled(false); |
| suiv.setEnabled(false); |
| } |
| } |
| private void afficherImageSinonAfficherMessage(boolean afficherImage) { |
| if(afficherImage) { |
| htmlVide.setVisible(false); |
| } else { |
| setTitle(Msg.get("aucune-image-liee")); |
| afficherHtmlVide(); |
| } |
| image.setVisible(afficherImage); |
| } |
| private void afficherHtmlVide() { |
| String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-image-liee")+"</div>"; |
| htmlVide.setHeight("150px"); |
| htmlVide.setHTML(htmlDivVide); |
| htmlVide.setVisible(true); |
| } |
| /** |
| * Active visuellement le panneau et les boutons |
| */ |
| public void activerPanneau(boolean activer) { |
| if(activer) { |
| this.getEl().unmask(); |
| } else { |
| this.getEl().mask(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| // gestion du clic sur le bouton précedent |
| prev.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| if(infosImages.length != 0) { |
| if(index == 0) |
| { |
| index = infosImages.length - 1 ; |
| } |
| else |
| { |
| index-- ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| // gestion du clic sur le bouton suivant |
| suiv.addClickHandler(new ClickHandler() { |
| // en cas de clic |
| @Override |
| public void onClick(ClickEvent event) { |
| if(infosImages.length != 0) { |
| if(index == infosImages.length - 1) |
| { |
| index = 0 ; |
| } |
| else |
| { |
| index++ ; |
| } |
| afficherImage() ; |
| } |
| } |
| }); |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé à la vue |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Accesseur au conteneur de l'image |
| * |
| * @return le conteneur de l'image |
| */ |
| public Image getImage() { |
| return image; |
| } |
| /** |
| * Acesseurs pour l'identifiant de l'image |
| * @return l'id de l'image |
| */ |
| public String getIdImage() |
| { |
| return infosImages[index][0] ; |
| } |
| /** |
| * Accesseur pour le bouton précédent |
| * |
| * @return le bouton précédent |
| */ |
| public com.google.gwt.user.client.ui.Button getPrev() { |
| return prev; |
| } |
| /** |
| * Accesseur pour le bouton suivant |
| * |
| * @return le bouton suivant |
| */ |
| public com.google.gwt.user.client.ui.Button getSuiv() { |
| return suiv; |
| } |
| /** |
| * Setter pour la taille de l'image |
| * |
| * @param x |
| * la largeur en pixels |
| * @param y |
| * la hauteur en pixels |
| */ |
| public void setTailleImage(int x, int y) { |
| imageHeight = y; |
| imageWidth = x; |
| } |
| /** |
| * Setteur pour l'identifiant de l'image |
| * @param id le nouvel identifiant |
| */ |
| public void setIdImage(String id) |
| { |
| idImage = id ; |
| } |
| /** |
| * renvoie la taille originale de l'image |
| * |
| * @return un tableau de deux entiers contenant la largeur puis la hauteur |
| */ |
| public int[] getTailleImage() { |
| int[] taille = { imageHeight, imageWidth }; |
| return taille; |
| } |
| /** |
| * Accesseur pour le conteneur de l'image |
| * @return le conteur de l'image |
| */ |
| public Panel getImageConteneur() { |
| return imageConteneur; |
| } |
| public void raz() { |
| infosImages = new String[0][0] ; |
| getImage().setUrl(""); |
| } |
| public void supprimerLiaisonImage() { |
| if(infosImages.length > 0) { |
| getImage().setUrl("") ; |
| int nouvelleTaille = infosImages.length - 1 ; |
| int indexSupp = index ; |
| String[][] nouveauInfosImages = new String[nouvelleTaille][3] ; |
| int j = 0 ; |
| for(int i = 0 ; i < infosImages.length ; i++) { |
| if(i != indexSupp) { |
| nouveauInfosImages[j] = infosImages[i] ; |
| j++ ; |
| } |
| } |
| infosImages = nouveauInfosImages ; |
| index = 0 ; |
| afficherImage() ; |
| } |
| } |
| public void afficherMenu(int[] xy) { |
| Menu mn = new Menu() ; |
| final Item suppLiaison = new Item(Msg.get("supprimer-liaison")); |
| mn.addItem(suppLiaison) ; |
| mn.addListener(new MenuListenerAdapter() { |
| @Override |
| public void onItemClick(BaseItem item, EventObject e) { |
| // si c'est l'aide |
| if (item.equals(suppLiaison)) { |
| // on notifie le médiateur |
| getIMediateur().supprimerLiaisonObsImage() ; |
| } |
| } |
| }) ; |
| mn.showAt(xy) ; |
| } |
| /** |
| * Verifie si l'image est plus grande que le conteneur et la retaille le cas |
| * echeant |
| */ |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| int[] dim = calculerDimensions(getTailleImage(),300,imageConteneur.getWidth()); |
| getImage().setSize("" + dim[0] + "px", |
| "" + dim[1] + "px"); |
| doLayout(); |
| if(imgZoom.isVisible()) { |
| agrandirImage(); |
| } |
| } |
| public int[] calculerDimensions(int[] tailleXY, double tailleMax, double tailleConteneur) { |
| float[] tailleXYf = {new Float(tailleXY[0]),new Float(tailleXY[1])} ; |
| float tailleOr = Math.min(new Float(tailleMax),new Float(tailleConteneur)) ; |
| float maxTaille = Math.max(tailleXYf[1],tailleXYf[0]) ; |
| float[] XYresize = new float[2]; |
| if(maxTaille == tailleXY[0]) { |
| float rapport = tailleXYf[1]/tailleXYf[0] ; |
| XYresize[0] = tailleOr ; |
| XYresize[1] = tailleOr*rapport ; |
| }else { |
| float rapport = tailleXYf[0]/tailleXYf[1] ; |
| XYresize[1] = tailleOr ; |
| XYresize[0] = tailleOr*rapport ; |
| } |
| int[] res = {(int)Math.round(XYresize[0]*0.85),(int)Math.round(XYresize[1]*0.85)} ; |
| return res; |
| } |
| protected void agrandirImage() { |
| String urlAgrandie = ""; |
| if(infosImages == null) { |
| urlAgrandie = "ill_liaison.png"; |
| setTailleImage(265, 270); |
| } else { |
| urlAgrandie = getUrlAgrandie(index); |
| } |
| if(imgAgrandie == null) { |
| imgAgrandie = new Image(urlAgrandie); |
| imgZoom.add(imgAgrandie); |
| imgAgrandie.addLoadHandler(new LoadHandler() { |
| @Override |
| public void onLoad(LoadEvent event) { |
| int[] tailleImage = calculerDimensions(getTailleImage(),getTailleImage()[1],Window.getClientHeight()*0.75); |
| ExtElement imgElement = Ext.get(imgAgrandie.getElement()); |
| if(animerTransition) { |
| AnimationConfig a = new AnimationConfig() ; |
| a.setDuration(dureeAnimation); |
| imgElement.setHeight(tailleImage[1], a); |
| imgElement.setWidth(tailleImage[0], a); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], a); |
| winElement.setWidth(tailleImage[0], a); |
| } else { |
| imgElement.setHeight(tailleImage[1], false); |
| imgElement.setWidth(tailleImage[0], false); |
| ExtElement winElement = Ext.get(imgZoom.getElement()); |
| winElement.setHeight(tailleImage[1], false); |
| winElement.setWidth(tailleImage[0], false); |
| } |
| } |
| }); |
| } else { |
| imgAgrandie.setUrl(urlAgrandie); |
| imgAgrandie.setVisible(true); |
| } |
| } |
| private String getUrlMiniature(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatGalerie(); |
| } |
| private String getUrlAgrandie(int index) { |
| String[][] paramsImage = {{"id_image",infosImages[index][0]}}; |
| ImageCarnet ic = new ImageCarnet(paramsImage); |
| return ic.getUrlFormatZoom(); |
| } |
| private void afficherPanneauAgrandi() { |
| agrandirImage(); |
| imgZoom.show(this.getElement()); |
| imgZoom.setPosition((int)(Window.getClientWidth() - Window.getClientWidth()*0.50),(int)(Window.getClientHeight() - Window.getClientHeight()*0.85)); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/indicateurs/InformationRepartitionVue.java |
|---|
| New file |
| 0,0 → 1,214 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant la repartition d'une plante |
| * |
| * @author David Delon |
| * |
| */ |
| public class InformationRepartitionVue extends Panel implements Rafraichissable { |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private HTML htmlVide = new HTML(); |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </div>") ; |
| com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private InformationRepartitionVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public InformationRepartitionVue(ObservationMediateur obs) { |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| @Override |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| image.sinkEvents(Event.ONDBLCLICK); |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| this.setCls("x-image-info-rep") ; |
| add(image); |
| add(htmlVide); |
| image.setPixelSize(150, 150); |
| afficherImageSinonAfficherMessage(false); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| private void afficherImageSinonAfficherMessage(boolean afficherImage) { |
| if(afficherImage) { |
| htmlVide.setVisible(false); |
| } else { |
| afficherHtmlVide(); |
| } |
| image.setVisible(afficherImage); |
| } |
| private void afficherHtmlVide() { |
| String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-carte-taxon")+"</div>"; |
| htmlVide.setHeight("150px"); |
| htmlVide.setHTML(htmlDivVide); |
| htmlVide.setVisible(true); |
| } |
| /** |
| * Affichage carte de repartition |
| * |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String) { |
| urlImage=(String) nouvelleDonnees; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0) { |
| afficherImageSinonAfficherMessage(false); |
| } |
| else { |
| afficherImageSinonAfficherMessage(true); |
| image.setUrl(urlImage); |
| verifierEtRetaillerImage(); |
| } |
| } |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| String urlAgrandie = urlImage.replace("min", "max"); |
| imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlAgrandie+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/indicateurs/ImageGeneriqueVue.java |
|---|
| New file |
| 0,0 → 1,237 |
| package org.tela_botanica.client.vues.observation.indicateurs; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.DOM; |
| import com.google.gwt.user.client.Event; |
| import com.google.gwt.user.client.Window; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.Image; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.ToolTip; |
| /** |
| * Un panneau affichant une image generique provenant d eflore |
| * |
| * @author David Delon |
| * |
| */ |
| public class ImageGeneriqueVue extends Panel implements Rafraichissable { |
| /** |
| * Le médiateur associé |
| */ |
| private ObservationMediateur observationMediateur = null; |
| /** |
| * l'image à afficher |
| */ |
| private Image image = new Image(); |
| private String urlImage = "" ; |
| private String urlImageMax = "" ; |
| private HTML htmlVide = new HTML(); |
| private com.gwtext.client.widgets.Window imgZoom = new com.gwtext.client.widgets.Window(Msg.get("agrandissement")) ; |
| private ToolTip tp = new ToolTip("<div class=\"x-tooltip-help\"> " + Msg.get("double-clic-agrandir") + " </div>") ; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private ImageGeneriqueVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec argument |
| * @param obs le médiateur à associer |
| */ |
| public ImageGeneriqueVue(ObservationMediateur obs) { |
| this.observationMediateur = obs; |
| imgZoom.setCloseAction(com.gwtext.client.widgets.Window.HIDE) ; |
| image = new Image() { |
| @Override |
| public void onBrowserEvent(Event event) { |
| // lors du double clic |
| if (Event.ONDBLCLICK == DOM.eventGetType(event)) { |
| // on notifie le médiateur |
| agrandirImage() ; |
| } |
| } |
| }; |
| tp.applyTo(image.getElement()) ; |
| this.setCls("x-image-gen") ; |
| imgZoom.setConstrain(true); |
| imgZoom.setAutoHeight(true) ; |
| imgZoom.setAutoWidth(true) ; |
| htmlVide.setHeight("0px"); |
| htmlVide.setVisible(false); |
| add(image); |
| add(htmlVide); |
| image.setPixelSize(150, 150); |
| image.sinkEvents(Event.ONDBLCLICK); |
| afficherImageSinonAfficherMessage(false); |
| // on ajoute les listeners |
| ajouterListeners(); |
| } |
| /** |
| * Affichage image generique |
| * |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees,boolean repandreRaffraichissement) { |
| // si on recoit une String contenant une URL |
| if (nouvelleDonnees instanceof String []) { |
| String [] lecteurDonnees = (String []) nouvelleDonnees; |
| urlImage=lecteurDonnees[0]; |
| urlImageMax=lecteurDonnees[1]; |
| if (urlImage == null || urlImage.equals("null") || urlImage.length()==0 || urlImage.equals("")) { |
| afficherHtmlVide(); |
| image.setVisible(false); |
| } |
| else { |
| afficherImageSinonAfficherMessage(true); |
| image.setUrl(urlImage); |
| image.setPixelSize(150, 150); |
| verifierEtRetaillerImage(); |
| } |
| } else { |
| afficherImageSinonAfficherMessage(false); |
| } |
| observationMediateur.deMasquerChargementInfosObservations() ; |
| } |
| private void afficherImageSinonAfficherMessage(boolean afficherImage) { |
| if(afficherImage) { |
| htmlVide.setVisible(false); |
| } else { |
| afficherHtmlVide(); |
| } |
| image.setVisible(afficherImage); |
| } |
| private void afficherHtmlVide() { |
| String htmlDivVide = "<div class=\"aucune_image_pour\"> "+Msg.get("aucune-image-taxon")+"</div>"; |
| htmlVide.setHeight("150px"); |
| htmlVide.setHTML(htmlDivVide); |
| htmlVide.setVisible(true); |
| } |
| public void agrandirImage() { |
| if(!imgZoom.isVisible()) |
| { |
| imgZoom.setHtml("<img height="+Window.getClientHeight()*0.75+"px src=\""+urlImageMax+"\" />") ; |
| imgZoom.setPagePosition( Window.getClientWidth()/2, Window.getClientHeight()/5) ; |
| imgZoom.show(this.getElement()) ; |
| } else { |
| imgZoom.hide(); |
| } |
| } |
| /** |
| * Ajoute les listeners pour la gestions d'évènement |
| */ |
| public void ajouterListeners() { |
| } |
| public void raz() { |
| image.setUrl(""); |
| } |
| public void verifierEtRetaillerImage() { |
| // si l'image est nulle |
| if (image == null) { |
| // on ne fait rien |
| return; |
| } |
| // on prend la taille originale de l'image |
| int originalX = image.getWidth(); |
| int originalY = image.getHeight(); |
| // on la transforme en float (la division entre entier donne de curieux |
| // résultats) |
| float fOriginalX = (new Float(originalX)).floatValue(); |
| float fOriginalY = (new Float(originalY)).floatValue(); |
| // et on fait le rapport longueur sur hauteur (pour connaitre le ratio) |
| float rapportTaille = fOriginalX / fOriginalY; |
| // la nouvelle taille est pour le moment égale à l'ancienne |
| int nouvelleTailleX = originalX; |
| int nouvelleTailleY = originalY; |
| // on prend la taille du conteneur |
| int tailleConteneurX = getWidth(); |
| int tailleConteneurY = getHeight(); |
| int maxConteneur = Math.min(tailleConteneurX, tailleConteneurY); |
| int max = Math.min(maxConteneur, 300); |
| // si l'image ne rentre pas telle quelle (longueur ou hauteur trop |
| // grande) |
| // si la longueur de l'image est la plus grande des deux |
| int maxImage = Math.max(originalX, originalY); |
| if(maxImage == originalX) { |
| // on prend la longueur comme taille de référence, qu'on met à |
| // la longueur du conteneur |
| nouvelleTailleX = max; |
| // et on recalcule la hauteur, par rapport à la nouvelle |
| // longueur, en gardant le format de 'limage |
| nouvelleTailleY = (int) Math.floor(nouvelleTailleX * 1 |
| / rapportTaille); |
| } |
| else |
| { |
| // si la hauteur est la plus grande, on fait le même genre |
| // d'opération en prenant la hauteur comme référence |
| nouvelleTailleY = max; |
| nouvelleTailleX = (int) Math.floor(nouvelleTailleY |
| * rapportTaille); |
| } |
| // on modifie enfin la taille de l'image pour qu'elle soit affichée |
| image.setPixelSize(nouvelleTailleX , |
| nouvelleTailleY); |
| doLayout(); |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/FormulaireImportObservationVue.java |
|---|
| New file |
| 0,0 → 1,174 |
| package org.tela_botanica.client.vues.observation; |
| import java.util.Iterator; |
| import java.util.Map; |
| import org.tela_botanica.client.i18n.I18n; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielChampsEtendusDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeGroupesChampsEtendus; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import org.tela_botanica.client.util.Util; |
| import com.google.gwt.core.client.Callback; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.user.client.ui.FileUpload; |
| import com.google.gwt.user.client.ui.FormPanel; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteEvent; |
| import com.google.gwt.user.client.ui.FormPanel.SubmitCompleteHandler; |
| import com.google.gwt.user.client.ui.HTML; |
| import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
| import com.google.gwt.user.client.ui.Hidden; |
| import com.google.gwt.user.client.ui.HorizontalPanel; |
| import com.google.gwt.user.client.ui.ListBox; |
| import com.google.gwt.user.client.ui.VerticalPanel; |
| import com.google.gwt.user.client.ui.Widget; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Window; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| public class FormulaireImportObservationVue implements Rafraichissable { |
| private ObservationMediateur oMediateur = null; |
| private Window nPan = null; |
| private Hidden identifiant = null; |
| private static ListeGroupesChampsEtendus cacheGroupes; |
| ListBox listeGroupeChampsEtendus; |
| public FormulaireImportObservationVue(ObservationMediateur om) { |
| this.oMediateur = om; |
| nPan = new Window(Msg.get("import-observations")); |
| identifiant = new Hidden(); |
| identifiant.setName("utilisateur"); |
| identifiant.setValue(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| final FormPanel form = new FormPanel(); |
| final Button boutonValidation = new Button(Msg.get("envoyer")); |
| form.setEncoding(FormPanel.ENCODING_MULTIPART); |
| form.setMethod(FormPanel.METHOD_POST); |
| form.setWidth("450px"); |
| nPan.setWidth("450px"); |
| VerticalPanel holder = new VerticalPanel(); |
| FileUpload upload = new FileUpload(); |
| upload.setName("upload"); |
| holder.add(upload); |
| holder.add(boutonValidation); |
| holder.add(identifiant); |
| listeGroupeChampsEtendus = new ListBox(); |
| listeGroupeChampsEtendus.addStyleName("liste_projets_import"); |
| if(cacheGroupes == null) { |
| ListeReferentielChampsEtendusDAO lrceDao = new ListeReferentielChampsEtendusDAO(null); |
| lrceDao.obtenirGroupesChampsEtendus(this); |
| } else { |
| this.rafraichir(cacheGroupes, false); |
| } |
| HTML lienVersDocumentModele = new HTML("<a href=\"#\">" + Msg.get("telecharger-modele") + "</a>"); |
| lienVersDocumentModele.addClickHandler(new ClickHandler() { |
| @Override |
| public void onClick(ClickEvent event) { |
| String groupeimport = listeGroupeChampsEtendus.getValue(listeGroupeChampsEtendus.getSelectedIndex()); |
| String urlTplImport = Configuration.getServiceBaseUrl() + "/ImportXLS/template?groupe="+groupeimport; |
| com.google.gwt.user.client.Window.open(urlTplImport, "", ""); |
| } |
| }); |
| HorizontalPanel holHoriz = new HorizontalPanel(); |
| holHoriz.add(lienVersDocumentModele); |
| holHoriz.add(listeGroupeChampsEtendus); |
| holder.add(holHoriz); |
| holder.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT); |
| boutonValidation.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| form.submit(); |
| } |
| }); |
| form.add(holder); |
| nPan.add(form); |
| form.setAction(Configuration.getServiceBaseUrl() + "/ImportXLS"); |
| form.addSubmitCompleteHandler(new SubmitCompleteHandler() { |
| @Override |
| public void onSubmitComplete(SubmitCompleteEvent event) { |
| // Certains client ne savent pas lire le retour d'upload correctement |
| // notamment à cause des requêtes CORS, donc en cas de problème on |
| // appelle manuellement les stats d'upload en lecture |
| if(event.getResults() != null) { |
| try { |
| Map<String, String> retourImport = Util.parserRetourImportObs(event.getResults()); |
| surRetourImport(retourImport); |
| } catch (Exception e) { |
| demanderStatsUpload(); |
| } |
| } else { |
| demanderStatsUpload(); |
| } |
| } |
| }); |
| } |
| private void demanderStatsUpload() { |
| Util.envoyerRequeteStatsUpload(new Callback<String, String>() { |
| @Override |
| public void onSuccess(String resultats) { |
| Map<String, String> retourImport = Util.parserRetourImportObs(resultats); |
| surRetourImport(retourImport); |
| } |
| @Override |
| public void onFailure(String reason) { |
| // TODO: rien à faire, si la requête échoue c'est que le serveur |
| // ne répond pas et donc on a déjà eu des problèmes en amont |
| } |
| }); |
| } |
| private void surRetourImport(Map<String, String> retourImport) { |
| String message = ""; |
| for (Iterator<String> iterator = retourImport.keySet().iterator(); iterator |
| .hasNext();) { |
| String indexRapport = iterator.next(); |
| // on ne met pas de "-" dans les clés json, mais par contre nos clé i18n |
| // sont séparées par des tirets, donc on remplace |
| String cleI18n = indexRapport.replace("_", "-"); |
| String[] StrParams = {retourImport.get(indexRapport).replace("\"", "")}; |
| message += Msg.get(cleI18n, StrParams)+"\n"; |
| } |
| com.google.gwt.user.client.Window.alert(message); |
| nPan.close(); |
| oMediateur.obtenirDernierePageObservation(); |
| } |
| public void afficher() { |
| nPan.show(); |
| } |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof ListeGroupesChampsEtendus) { |
| cacheGroupes = (ListeGroupesChampsEtendus)nouvelleDonnees; |
| listeGroupeChampsEtendus.addItem(Msg.get("import-standard"), ""); |
| for (Iterator<String> iterator = cacheGroupes.getCorrespondancesCorrespondancesIdsNomsGroupes().keySet().iterator(); iterator.hasNext();) { |
| String cleGroupe = iterator.next(); |
| String[] strParams = {cleGroupe}; |
| listeGroupeChampsEtendus.addItem(Msg.get("import-champs-projets", strParams), cleGroupe); |
| } |
| } |
| } |
| } |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/ListeObservationVue.java |
|---|
| New file |
| 0,0 → 1,1005 |
| 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(); |
| } |
| }; |
| // Le changement de tri n'est pas immédiat et si on recharge le liste tout de suite |
| // on a l'ancien tri et pas le nouveau (200 millisecondes suffisent et ne se voient pas) |
| // #mondeDeMerde |
| 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 |
| /branches/v2.23-rouleau/src/org/tela_botanica/client/vues/observation/MotsClesObsVue.java |
|---|
| New file |
| 0,0 → 1,197 |
| package org.tela_botanica.client.vues.observation; |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Filtrable; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.observation.ObservationMediateur; |
| import com.google.gwt.user.client.ui.Label; |
| import com.gwtext.client.core.EventObject; |
| import com.gwtext.client.widgets.Button; |
| import com.gwtext.client.widgets.Panel; |
| import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
| import com.gwtext.client.widgets.event.KeyListener; |
| import com.gwtext.client.widgets.form.TextField; |
| public class MotsClesObsVue extends Panel implements Filtrable, Rafraichissable { |
| private ObservationMediateur oMediateur = null ; |
| /** |
| * Barre de recherche |
| * |
| */ |
| private TextField champRecherche = null; |
| /** |
| * Booleen d'etat du filtre |
| */ |
| private boolean filtreModifie = false; |
| /** |
| * mot(s) à chercher |
| */ |
| private String motsAChercher = ""; |
| /** |
| * bouton de validation |
| */ |
| private Button ok = null ; |
| private Button afficherNuage = null; |
| /** |
| * Constructeur sans argument (privé car ne doit pas être utilisé) |
| */ |
| @SuppressWarnings("unused") |
| private MotsClesObsVue() { |
| super(); |
| } |
| /** |
| * Constructeur avec médiateur |
| * |
| * @param im |
| */ |
| public MotsClesObsVue(ObservationMediateur om) { |
| super(); |
| oMediateur = om; |
| Label labelRecherche = new Label(Msg.Get("mots-cles") + " :"); |
| champRecherche = new TextField(); |
| ok = new Button(Msg.get("rechercher")); |
| afficherNuage = new Button(Msg.get("voir-mots-cles")); |
| add(labelRecherche); |
| add(champRecherche); |
| add(ok); |
| add(afficherNuage); |
| setPaddings(5); |
| setBorder(false); |
| setCollapsible(true); |
| ajouterListeners(); |
| } |
| /** |
| * ajoute des listeners |
| */ |
| private void ajouterListeners() { |
| // gestion de la touche entrée |
| champRecherche.addKeyListener(EventObject.ENTER, new KeyListener() { |
| @Override |
| public void onKey(int key, EventObject e) { |
| valider(); |
| } |
| }); |
| ok.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| valider(); |
| } |
| }); |
| afficherNuage.addListener(new ButtonListenerAdapter() { |
| @Override |
| public void onClick(Button button, EventObject e) { |
| // oMediateur.afficherNuageMotsCles(); |
| } |
| }); |
| } |
| /** |
| * Fonction héritée de l'interface rafraichissable |
| */ |
| @Override |
| public void rafraichir(Object nouvelleDonnees, |
| boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof String) { |
| champRecherche.setValue(champRecherche.getValueAsString()+" "+(String)nouvelleDonnees); |
| } |
| filtreModifie = false; |
| } |
| /** |
| * renvoie l'état du filtre (modifié ou non) |
| * |
| * @return l'état du filtre |
| */ |
| @Override |
| public boolean renvoyerEtatFiltre() { |
| return filtreModifie; |
| } |
| /** |
| * Renvoie le nom du filtre |
| * |
| * @return le nom du filtre |
| */ |
| @Override |
| public String renvoyerNomFiltre() { |
| return "Recherche Mots clés"; |
| } |
| /** |
| * Renvoie un tableau contenant le nom du champ à filtrer et la valeur |
| * |
| * @return un tableau contenant le nom du champ à filtrer et sa valeur |
| */ |
| @Override |
| public String[] renvoyerValeursAFiltrer() { |
| String[] valeurFiltre = new String[0]; |
| if(!motsAChercher.equals("")) { |
| valeurFiltre = new String[2]; |
| valeurFiltre[0] = "mots_cles"; |
| valeurFiltre[1] = motsAChercher; |
| } |
| return valeurFiltre; |
| } |
| /** |
| * Accesseur pour le médiateur |
| * |
| * @return le médiateur associé |
| */ |
| public ObservationMediateur getIMediateur() { |
| return oMediateur; |
| } |
| /** |
| * Effectue quelque opérations dans la classe et envoie une requête de |
| * données au médiateur |
| */ |
| @Override |
| public void valider() { |
| filtreModifie = true; |
| motsAChercher = champRecherche.getText(); |
| oMediateur.obtenirNombreObservation(); |
| } |
| /** |
| * Affiche la fenetre |
| */ |
| public void afficherFiltre() { |
| champRecherche.setValue(motsAChercher); |
| } |
| @Override |
| public void viderFiltre() { |
| champRecherche.setValue(""); |
| motsAChercher = ""; |
| } |
| } |
| Property changes: |
| Added: svn:mergeinfo |