/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/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/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/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 |