/trunk/src/org/tela_botanica/client/CarnetEnLigne.java |
---|
File deleted |
/trunk/src/org/tela_botanica/client/CarnetEnLigneModele.java |
---|
5,60 → 5,88 |
* Ne previent pas les vues. Est appelle par le mediateur qui traite le resultat. |
*/ |
import org.tela_botanica.client.interfaces.iRetourUtilisateur; |
import org.tela_botanica.client.modeles.Utilisateur; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.Configuration; |
import org.tela_botanica.client.modeles.UtilisateurAsynchroneDAO; |
import com.google.gwt.i18n.client.Dictionary; |
public class CarnetEnLigneModele { |
private final String baseURL; // Url d'appel aux services |
/** |
* booleen qui verifie l'unicite de l'instance |
*/ |
private static boolean estInstancie = false ; |
/** |
* La configuration en cours |
*/ |
private Configuration config = null; |
/** |
* Constructeur |
*/ |
public static CarnetEnLigneModele Instance() |
{ |
if(!estInstancie) |
{ |
estInstancie = true ; |
return new CarnetEnLigneModele() ; |
} |
else |
{ |
return null ; |
} |
} |
private CarnetEnLigneModele() { |
config = new Configuration(); |
} |
public CarnetEnLigneModele() { |
baseURL = Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
public void deconnecterUtilisateur(Rafraichissable r, String user) { |
new UtilisateurAsynchroneDAO(this).deconnecterUtilisateur(r,user ); |
} |
/** |
* |
* |
*/ |
public void connecterUtilisateur(Rafraichissable r, String login , String password) { |
new UtilisateurAsynchroneDAO(this).connecteUtilisateur(r,login, password ); |
} |
public void getUtilisateurAsynchroneDAO(final iRetourUtilisateur retour) { |
new UtilisateurAsynchroneDAO().getUtilisateur(baseURL, retour); |
public void getEtatUtilisateur(Rafraichissable r) { |
new UtilisateurAsynchroneDAO(this).getEtatUtilisateur(r); |
} |
/** |
* Accesseur pour la configuration en cours d'utilisation |
* |
* |
* @return la configuration |
*/ |
public Utilisateur getUtilisateurSynchroneDAO() { |
public Configuration getConfig() { |
return new Utilisateur("David Delon synchrone", true); |
return config; |
} |
public void deconnecterUtilisateur(final iRetourUtilisateur retour, |
String user) { |
new UtilisateurAsynchroneDAO().deconnecterUtilisateur(baseURL, retour, |
user); |
} |
public void connecterUtilisateur(final iRetourUtilisateur retour, |
String login, String password) { |
new UtilisateurAsynchroneDAO().connecteUtilisateur(baseURL, retour, |
login, password); |
} |
} |
/trunk/src/org/tela_botanica/client/cel2.java |
---|
15,8 → 15,20 |
*/ |
public void onModuleLoad() { |
ImageMediateur im = ImageMediateur.Instance(); |
//ImageMediateur im = ImageMediateur.Instance(); |
new Viewport(im.getPanneauPrincipalImage()); |
//new Viewport(im.getPanneauPrincipalImage()); |
CarnetEnLigneMediateur carnetEnLigneMediateur= CarnetEnLigneMediateur.Instance(); |
new Viewport(carnetEnLigneMediateur.getPanneauPrincipalCarnetEnLigne()); |
// On appelle la gestion de l'identification |
// Veillez d'ailleurs a ne pas appeller de services dans les constructeurs |
carnetEnLigneMediateur.getEtatUtilisateur(); |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/ObservationAsynchroneDAO.java |
---|
File deleted |
/trunk/src/org/tela_botanica/client/modeles/Observation.java |
---|
1,42 → 1,30 |
package org.tela_botanica.client.modeles; |
public class Observation { |
private int nombreObservations = 0; |
private Observation[] listeObservation = null; |
private String transmis = null; |
private String nomSaisi = null; |
private String nomRetenu = null; |
private String numeroNomenclatural = null; |
private String numeroTaxonomique = null; |
private String famille = null; |
private String localite = null; |
private String lieudit = null; |
private String station = null; |
private String milieu = null; |
private String commentaire = null; |
private String date = null; |
private String numeroOrdre = null; |
private String transmis=null; |
private String nomSaisi=null; |
private String nomRetenu=null; |
private String numeroNomenclatural=null; |
private String numeroTaxonomique=null; |
private String famille=null; |
private String localite=null; |
private String lieudit=null; |
private String station=null; |
private String milieu=null; |
private String commentaire=null; |
private String date=null; |
private String numeroOrdre=null; |
public Observation() { |
} |
/** |
* Constructeur nombre total d'observations |
* |
* @param i |
*/ |
public Observation(int i) { |
nombreObservations = i; |
} |
public int getNombreObservations() { |
return nombreObservations; |
} |
/** |
* @param transmis |
* @param nomSaisi |
* @param nomRetenu |
51,11 → 39,8 |
* @param date |
* @param numeroOrdre |
*/ |
public Observation(String transmis, String nomSaisi, String nomRetenu, |
String numeroNomenclatural, String numeroTaxonomique, |
String famille, String localite, String lieudit, String station, |
String milieu, String commentaire, String date, String numeroOrdre) { |
public Observation(String transmis, String nomSaisi, String nomRetenu, String numeroNomenclatural, String numeroTaxonomique, String famille, String localite, String lieudit, String station, String milieu, String commentaire, String date, String numeroOrdre) { |
this.transmis = transmis; |
this.nomSaisi = nomSaisi; |
this.nomRetenu = nomRetenu; |
69,19 → 54,74 |
this.commentaire = commentaire; |
this.date = date; |
this.numeroOrdre = numeroOrdre; |
} |
public String getNomSaisi() { |
return nomSaisi; |
} |
public Observation(Observation[] listeObservation) { |
this.listeObservation = listeObservation; |
public String getNumeroOrdre() { |
return numeroOrdre; |
} |
public Observation[] getListeObservation() { |
return listeObservation; |
public String getCommentaire() { |
return commentaire; |
} |
public String getNomSaisi() { |
return nomSaisi; |
public String getDate() { |
return date; |
} |
public String getFamille() { |
return famille; |
} |
public String getLieudit() { |
return lieudit; |
} |
public String getLocalite() { |
return localite; |
} |
public String getMilieu() { |
return milieu; |
} |
public String getNomRetenu() { |
return nomRetenu; |
} |
public String getNumeroNomenclatural() { |
return numeroNomenclatural; |
} |
public String getNumeroTaxonomique() { |
return numeroTaxonomique; |
} |
public String getStation() { |
return station; |
} |
public String getTransmis() { |
return transmis; |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/ListeObservation.java |
---|
New file |
0,0 → 1,50 |
package org.tela_botanica.client.modeles; |
import java.util.HashMap; |
/** |
* table de hachage composée d'observation, renvoyé par les objets de type DAO |
* pour les images. |
* La clé est l'identifiant de l'observation dans la base de données, et la valeur un objet |
* de type Observation |
* GWT ne supporte pas encore les type paramètres mais quand il le fera il faudra créer la HashMap |
* avec <String,Observation> |
* @author david delon |
* |
*/ |
public class ListeObservation extends HashMap { |
/** |
* Constructeur sans paramètres |
*/ |
public ListeObservation() |
{ |
super(); |
} |
/** |
* Constructeur avec paramètre |
* @param taille la taille de la table de hachage |
*/ |
public ListeObservation(int taille) |
{ |
super(taille); |
} |
/** |
* Constructeur avec paramètre |
* @param ic un tableau d'ImageCarnet |
*/ |
public ListeObservation(Observation[] obs) |
{ |
super() ; |
for (int i = 0; i < obs.length; i++) |
{ |
if(obs[i] != null && obs[i] instanceof Observation) |
{ |
this.put(obs[i].getNumeroOrdre(),obs[i]); |
} |
} |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/ListeReferentielCommuneAsynchroneDAO.java |
---|
New file |
0,0 → 1,98 |
package org.tela_botanica.client.modeles; |
import org.tela_botanica.client.Util; |
import org.tela_botanica.client.interfaces.FournisseurListe; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.observation.ObservationModele; |
import com.google.gwt.json.client.JSONArray; |
import com.google.gwt.json.client.JSONParser; |
import com.google.gwt.json.client.JSONString; |
import com.google.gwt.json.client.JSONValue; |
import com.google.gwt.user.client.HTTPRequest; |
import com.google.gwt.user.client.ResponseTextHandler; |
/** |
* DAO la liste des observations attachées a un observateur |
* @author David Delon |
* |
*/ |
public class ListeReferentielCommuneAsynchroneDAO implements FournisseurListe { |
/** |
* Le modèle associé au DAO |
*/ |
private ObservationModele observationModele = null ; |
public ListeReferentielCommuneAsynchroneDAO(ObservationModele observationModele) |
{ |
this.observationModele=observationModele; |
} |
/** |
* Envoie une requete au serveur jrest pour obtenir les communes correspondant |
* à des critères données en paramètres |
* @param r le rafraichissable qui demande la mise à jour |
* @param criteres un string contenant le terme a rechercher |
*/ |
public void obtenirListeDonnees(final Rafraichissable r, String critere) |
{ |
// on envoie le get asynchrone |
HTTPRequest.asyncGet(observationModele.getConfig().getServiceBaseUrl()+"/LocationSearch/"+critere, new ResponseTextHandler() { |
// si tout se passe bien on reçoit une réponse JSON |
public void onCompletion(String responseText) { |
final ListeReferentielCommune referentielCommuneData ; |
final JSONValue responseValue = JSONParser.parse(responseText); |
JSONArray reponse=null; |
// si c'est un tableau |
if ((reponse=responseValue.isArray()) != null) { |
JSONArray communes; |
final int taillemax = reponse.size(); |
referentielCommuneData = new ListeReferentielCommune(taillemax); |
for (int i = 0; i < taillemax; i++) { |
if ((communes=reponse.get(i).isArray()) != null) { |
String commune=((JSONString) communes.get(0)).stringValue(); |
String departement=((JSONString) communes.get(0)).stringValue(); |
ReferentielCommune com=new ReferentielCommune(commune, departement); |
referentielCommuneData.put(com.getCommune()+com.getDepartement(),com); |
} |
} |
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
// le premier à les recevoir |
r.rafraichir(referentielCommuneData,true); |
} |
} |
}); |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/Utilisateur.java |
---|
2,21 → 2,21 |
public class Utilisateur { |
private String identifiant = null; |
private boolean identifie = false; |
private String identifiant=null; |
private boolean identifie=false; |
public Utilisateur(String identifiant, boolean identifie) { |
this.identifiant = identifiant; |
this.identifie = identifie; |
this.identifiant=identifiant; |
this.identifie=identifie; |
} |
/** |
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de |
* session |
* |
* Retourne l'identifiant de l'utilisateur identifie ou un identifiant de session |
* @return String identifiant |
*/ |
public String getIdentifiant() { |
return identifiant; |
} |
23,12 → 23,11 |
/** |
* Retourne vrai si utilisateur identifie |
* |
* @return boolean |
*/ |
public boolean isIdentifie() { |
return identifie; |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/ListeObservationAsynchroneDAO.java |
---|
New file |
0,0 → 1,121 |
package org.tela_botanica.client.modeles; |
import org.tela_botanica.client.Util; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.observation.ObservationModele; |
import com.google.gwt.json.client.JSONArray; |
import com.google.gwt.json.client.JSONParser; |
import com.google.gwt.json.client.JSONString; |
import com.google.gwt.json.client.JSONValue; |
import com.google.gwt.user.client.HTTPRequest; |
import com.google.gwt.user.client.ResponseTextHandler; |
/** |
* DAO la liste des observations attachées a un observateur |
* @author David Delon |
* |
*/ |
public class ListeObservationAsynchroneDAO { |
/** |
* Le modèle associé au DAO |
*/ |
private ObservationModele observationModele = null ; |
public ListeObservationAsynchroneDAO(ObservationModele observationModele) |
{ |
this.observationModele=observationModele; |
} |
/** |
* Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
* à des critères données en paramètres |
* @param r le rafraichissable qui demande la mise à jour |
* @param criteres un tableau nom/valeur des critères pour les observations |
*/ |
public void obtenirListeObservation(final Rafraichissable r, String utilisateur, String[][] criteres) |
{ |
String requete = "" ; |
if(criteres != null) |
{ |
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
// ils contiennent limite et taille page |
for (int i = 0; i < criteres.length; i++) { |
if(!criteres[i][1].equals("")) |
{ |
if(i!= 0) |
{ |
requete += "&"; |
} |
requete += criteres[i][0]+"="+criteres[i][1] ; |
} |
} |
} |
// on envoie le get asynchrone |
HTTPRequest.asyncGet(observationModele.getConfig().getServiceBaseUrl()+"/InventoryObservationList/"+utilisateur+"/"+requete, new ResponseTextHandler() { |
// si tout se passe bien on reçoit une réponse JSON |
public void onCompletion(String responseText) { |
final ListeObservation observationData ; |
final JSONValue responseValue = JSONParser.parse(responseText); |
JSONArray reponse=null; |
// si c'est un tableau |
if ((reponse=responseValue.isArray()) != null) { |
JSONArray observation; |
final int taillemax = reponse.size(); |
observationData = new ListeObservation(taillemax); |
for (int i = 0; i < taillemax; i++) { |
if ((observation=reponse.get(i).isArray()) != null) { |
String transmis=((JSONString) observation.get(13)).stringValue(); |
String nomSaisi=Util.toCelString(((JSONString) observation.get(0)).toString()); |
String nomRetenu=Util.toCelString(((JSONString) observation.get(2)).toString()); |
String numeroNomenclatural=((JSONString) observation.get(3)).stringValue(); |
String numeroTaxonomique=((JSONString) observation.get(4)).stringValue(); |
String famille=Util.toCelString(((JSONString) observation .get(5)).toString()); |
String localite=Util.toCelString(((JSONString) observation .get(6)).toString()); |
String lieudit=Util.toCelString(((JSONString) observation .get(9)).toString()); |
String station=Util.toCelString(((JSONString) observation .get(10)).toString()); |
String milieu=Util.toCelString(((JSONString) observation .get(11)).toString()); |
String commentaire=Util.toCelString(((JSONString) observation .get(12)).toString()); |
String date=((JSONString) observation .get(8)).stringValue(); |
String numeroOrdre=((JSONString) observation.get(7)).stringValue(); |
Observation obs=new Observation(transmis, nomSaisi, nomRetenu, numeroNomenclatural, numeroTaxonomique, famille, localite, lieudit, station, milieu, commentaire, date, numeroOrdre); |
observationData.put(obs.getNumeroOrdre(),obs); |
} |
} |
// dans tous les cas on transmet la liste crée au rafraichissable en lui demandant de répandre les données car il est |
// le premier à les recevoir |
r.rafraichir(observationData,true); |
} |
} |
}); |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/NombreObservationAsynchroneDAO.java |
---|
New file |
0,0 → 1,83 |
package org.tela_botanica.client.modeles; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.observation.ObservationModele; |
import com.google.gwt.json.client.JSONParser; |
import com.google.gwt.json.client.JSONString; |
import com.google.gwt.json.client.JSONValue; |
import com.google.gwt.user.client.HTTPRequest; |
import com.google.gwt.user.client.ResponseTextHandler; |
/** |
* DAO qui renvoie le nombre d'image associées à différents critères donnés (utile pour la pagination) |
* @author aurelien |
* |
*/ |
public class NombreObservationAsynchroneDAO { |
/** |
* Le modèle associé au DAO |
*/ |
private ObservationModele observationModele = null ; |
public NombreObservationAsynchroneDAO(ObservationModele observationModele) |
{ |
this.observationModele=observationModele; |
} |
/** |
* Envoie une requete au serveur jrest pour obtenir le nombre d'observation correspondant |
* à des critères données en paramètres |
* @param r le rafraichissable qui demande la mise à jour |
* @param criteres un tableau nom/valeur des critères pour les images |
*/ |
public void obtenirNombreObservation(final Rafraichissable r, String utilisateur, String[][] criteres) |
{ |
String requete = "" ; |
if(criteres != null) |
{ |
// on construit les paramètres du get avec les critères (&critere1=valeur1&critere2=valeur2 etc...) |
for (int i = 0; i < criteres.length; i++) { |
if(!criteres[i][1].equals("")) |
{ |
if(i!= 0) |
{ |
requete += "&"; |
} |
requete += criteres[i][0]+"="+criteres[i][1] ; |
} |
} |
} |
// on fait un get asynchrone |
HTTPRequest.asyncGet(observationModele.getConfig().getServiceBaseUrl()+"/InventoryObservationCount/"+utilisateur+"/"+requete, new ResponseTextHandler() { |
public void onCompletion(String responseText) { |
final JSONValue responseValue = JSONParser.parse(responseText); |
// si la requete se passe bien on reçoit un tableau JSON |
if(responseValue.isArray() != null) |
{ |
// qui contient une valeur : le nombre d'images correspondant au critères |
JSONValue res = responseValue.isArray().get(0) ; |
JSONString reponseNombre = res.isString() ; |
int maxObservations = Integer.parseInt(reponseNombre.stringValue()) ; |
int[] nbObservations = {maxObservations} ; |
// on le met dans un tableau d'entiers qu'on tranmset au demandeur de la mise à jour |
r.rafraichir(nbObservations, true) ; |
} |
} |
}) ; |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/UtilisateurAsynchroneDAO.java |
---|
5,7 → 5,8 |
* |
*/ |
import org.tela_botanica.client.interfaces.iRetourUtilisateur; |
import org.tela_botanica.client.CarnetEnLigneModele; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import com.google.gwt.json.client.JSONArray; |
import com.google.gwt.json.client.JSONBoolean; |
17,27 → 18,38 |
public class UtilisateurAsynchroneDAO { |
/** |
* Constructeur |
* Le modèle associé au DAO |
*/ |
public UtilisateurAsynchroneDAO() { |
private CarnetEnLigneModele carnetEnLigneModele = null ; |
/** |
* Constructeur |
*/ |
public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
this.carnetEnLigneModele=carnetEnLigneModele; |
} |
/** |
* Methode de classe d'appel du service gestion identification |
* |
* @param baseURL : |
* URL du service |
* @param retour : |
* methode appelle en retour d'appel |
* Methode de classe d'appel du service gestion identification |
* @param baseURL : URL du service |
* @param retour : methode appelle en retour d'appel |
*/ |
public void getEtatUtilisateur(final Rafraichissable r) { |
public void getUtilisateur(String baseURL, final iRetourUtilisateur retour) { |
// Recherche identifiant utilisateur identifie |
HTTPRequest.asyncGet(baseURL + "/User/", new ResponseTextHandler() { |
HTTPRequest.asyncGet(carnetEnLigneModele.getConfig().getServiceBaseUrl() + "/User/", new ResponseTextHandler() { |
public void onCompletion(String str) { |
JSONValue jsonValue = JSONParser.parse(str); |
45,12 → 57,12 |
if ((jsonArray = jsonValue.isArray()) != null) { |
String identifiant = ((JSONString) jsonArray.get(0)) |
.stringValue(); // Identifiant utilisateur ou |
// identifiant de session si non |
// identifie |
// identifiant de session si non |
// identifie |
boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
.booleanValue(); // Drapeau leve si utilisateur |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, identifie)); |
// deja identifie |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
57,58 → 69,55 |
} |
public void deconnecterUtilisateur(String baseURL, |
final iRetourUtilisateur retour, String user) { |
HTTPRequest.asyncGet(baseURL + "/User/" + user, |
public void deconnecterUtilisateur(final Rafraichissable r, String user) { |
HTTPRequest.asyncGet(carnetEnLigneModele.getConfig().getServiceBaseUrl()+ "/User/" + user , |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
JSONValue jsonValue = JSONParser.parse(str); |
JSONArray jsonArray; |
if ((jsonArray = jsonValue.isArray()) != null) { |
String identifiant = ((JSONString) jsonArray.get(0)) |
.stringValue(); // Identifiant utilisateur |
// ou |
// identifiant de session si non |
// identifie |
boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
.booleanValue(); // Drapeau leve si |
// utilisateur |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, |
identifie)); |
} |
JSONValue jsonValue = JSONParser.parse(str); |
JSONArray jsonArray; |
if ((jsonArray = jsonValue.isArray()) != null) { |
String identifiant = ((JSONString) jsonArray.get(0)) |
.stringValue(); // Identifiant utilisateur ou |
// identifiant de session si non |
// identifie |
boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
.booleanValue(); // Drapeau leve si utilisateur |
// deja identifie |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
}); |
} |
public void connecteUtilisateur(String baseURL, |
final iRetourUtilisateur retour, String login, String password) { |
HTTPRequest.asyncGet(baseURL + "/User/" + login + "/" + password, |
public void connecteUtilisateur (final Rafraichissable r, String login, String password) { |
HTTPRequest.asyncGet(carnetEnLigneModele.getConfig().getServiceBaseUrl() + "/User/" + login + "/" + password , |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
JSONValue jsonValue = JSONParser.parse(str); |
JSONArray jsonArray; |
if ((jsonArray = jsonValue.isArray()) != null) { |
String identifiant = ((JSONString) jsonArray.get(0)) |
.stringValue(); // Identifiant utilisateur |
// ou |
// identifiant de session si non |
// identifie |
.stringValue(); // Identifiant utilisateur ou |
// identifiant de session si non |
// identifie |
boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
.booleanValue(); // Drapeau leve si |
// utilisateur |
// deja identifie |
.booleanValue(); // Drapeau leve si utilisateur |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, |
identifie)); |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
115,4 → 124,7 |
} |
} |
/trunk/src/org/tela_botanica/client/modeles/ReferentielCommune.java |
---|
New file |
0,0 → 1,47 |
package org.tela_botanica.client.modeles; |
/** |
* |
* Classe representant un element du referentiel commune ou localite |
* |
*/ |
public class ReferentielCommune { |
private String commune=null; |
private String departement=null; |
public ReferentielCommune() { |
} |
/** |
* @param commune |
* @param departement |
*/ |
public ReferentielCommune(String commune, String departement) { |
this.commune = commune; |
this.departement = departement; |
} |
public String getCommune() { |
return commune; |
} |
public String getDepartement() { |
return departement; |
} |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/trunk/src/org/tela_botanica/client/modeles/ListeReferentielCommune.java |
---|
New file |
0,0 → 1,50 |
package org.tela_botanica.client.modeles; |
import java.util.HashMap; |
/** |
* table de hachage composée d'observation, renvoyé par les objets de type DAO |
* pour les images. |
* La clé est l'identifiant de l'observation dans la base de données, et la valeur un objet |
* de type Observation |
* GWT ne supporte pas encore les type paramètres mais quand il le fera il faudra créer la HashMap |
* avec <String,Observation> |
* @author david delon |
* |
*/ |
public class ListeReferentielCommune extends HashMap { |
/** |
* Constructeur sans paramètres |
*/ |
public ListeReferentielCommune() |
{ |
super(); |
} |
/** |
* Constructeur avec paramètre |
* @param taille la taille de la table de hachage |
*/ |
public ListeReferentielCommune(int taille) |
{ |
super(taille); |
} |
/** |
* Constructeur avec paramètre |
* @param ic un tableau d'ImageCarnet |
*/ |
public ListeReferentielCommune(ReferentielCommune[] com) |
{ |
super() ; |
for (int i = 0; i < com.length; i++) |
{ |
if(com[i] != null && com[i] instanceof ReferentielCommune) |
{ |
this.put(com[i].getCommune()+com[i].getDepartement(),com[i]); |
} |
} |
} |
} |
/trunk/src/org/tela_botanica/client/observation/EtatConnexionVue.java |
---|
File deleted |
/trunk/src/org/tela_botanica/client/observation/FormulaireDeConnexionVue.java |
---|
File deleted |
/trunk/src/org/tela_botanica/client/observation/ObservationMediateur.java |
---|
1,222 → 1,473 |
package org.tela_botanica.client.observation; |
import java.util.Iterator; |
import org.tela_botanica.client.CarnetEnLigneMediateur; |
import org.tela_botanica.client.interfaces.iMediateur; |
import org.tela_botanica.client.interfaces.iRetourObservation; |
import org.tela_botanica.client.interfaces.FournisseurListe; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.ListeObservation; |
import org.tela_botanica.client.modeles.Observation; |
import org.tela_botanica.client.vues.FormulaireSaisieObservationVue; |
import org.tela_botanica.client.vues.ListeObservationVue; |
import com.google.gwt.user.client.Window; |
import com.google.gwt.user.client.ui.RootPanel; |
import com.google.gwt.user.client.ui.VerticalPanel; |
import com.gwtext.client.data.ArrayReader; |
import com.gwtext.client.data.FieldDef; |
import com.gwtext.client.data.MemoryProxy; |
import com.gwtext.client.data.RecordDef; |
import com.gwtext.client.data.Store; |
import com.gwtext.client.data.StringFieldDef; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.TabPanel; |
public class ObservationMediateur implements iMediateur { |
/** |
* Mediateur gérant les interactions entre vues et les echanges de données |
* C'est un singleton. |
* @author aurelien |
* |
*/ |
public class ObservationMediateur implements Rafraichissable { |
/** |
* booleen qui verifie l'unicite de l'instance (donc static) |
*/ |
private static boolean estInstancie = false ; |
/** Mediateur general de l'application carnet en ligne |
* |
* |
*/ |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
/** |
* modele de données |
*/ |
private ObservationModele observationModele = null ; |
/** |
* panneau principal des Observation (onglet "observation") |
*/ |
private final Panel panneauPrincipalObservation = new Panel("Observation"); |
/** |
* panneau a onglet pour la liste |
*/ |
private TabPanel ongletsObservation = null ; |
/** |
* conteneur du panneau a onglets |
*/ |
private Panel panneauMenuEtOngletsObservation = null ; |
/** |
* liste détaillée des Observations |
*/ |
private ListeObservationVue listeObservation = null ; |
/** |
* Saisie des Observations |
*/ |
private FormulaireSaisieObservationVue formulaireSaisieObservationVue=null; |
/** |
* l'indice du dernier onglet sélectionné |
*/ |
private int dernierIndexOnglet = 0 ; |
/** |
* booleen explicitant s'il y a une selection en cours |
*/ |
private boolean selection = false ; |
// Evenenements |
final static public int NOMBRE_OBSERVATION = 1; |
/** |
* |
* 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 ; |
/** |
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande |
*/ |
private Store st = null ; |
/** |
* La liste des observations affichées en cours (verifier utilité) |
*/ |
private ListeObservation cacheObservation = new ListeObservation(0) ; |
/** |
/** |
* constructeur privé (on accède a la classe par la méthode getInstance |
*/ |
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur ) |
{ |
this.carnetEnLigneMediateur=carnetEnLigneMediateur; |
// Demande d'identification |
// afficherMenuId() ; |
final static public int LISTE_OBSERVATION = 2; |
// on crée un modèle |
observationModele = ObservationModele.Instance(this); |
// on gère la mise en page du panneau principal |
//panneauPrincipalObservation.setLayout(new BorderLayout()); |
// on crée le panneau qui contient les differentes onglets ainsi que le menu supérieur |
// panneauMenuEtOngletsObservation = new Panel("gg") ; |
// panneauMenuEtOngletsObservation.setLayout(new BorderLayout()) ; |
// le panneau à onglet qui contient la vue |
//ongletsObservation = new TabPanel(); |
// la liste des observations |
//Panel panneauListeObservation = new Panel("Liste"); |
listeObservation = new ListeObservationVue(this); |
// Le formulaire de saisie / modification d'observation |
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this); |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null; // Mediateur |
// General |
private final ObservationModele observationModele = new ObservationModele(); |
//panneauListeObservation.setLayout(new FitLayout()); |
//panneauListeObservation.setSize(600,600); |
//panneauListeObservation.add(listeObservation); |
// on ajoute les panneaux au panneau à onglets |
//ongletsObservation.add(panneauListeObservation); |
// les onglets au centre |
// panneauMenuEtOngletsObservation.add(ongletsObservation,regionCentre); |
// on ajoute le panneau qui contient le menu et les onglets d'images au centre |
//panneauPrincipalObservation.add(panneauMenuEtOngletsObservation,regionCentre); |
panneauPrincipalObservation.add(formulaireSaisieObservationVue); |
panneauPrincipalObservation.add(listeObservation); |
private Observation observation = null; |
} |
// Variable interne |
private final String texteDeconnexion = "Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica"; |
// Composants graphiques |
/** |
* Retourne une instance de manière unique |
* @return l'instance unique du médiateur |
*/ |
public static ObservationMediateur Instance(CarnetEnLigneMediateur carnetEnLigneMediateur) |
{ |
if(!estInstancie) |
{ |
estInstancie = true ; |
return new ObservationMediateur(carnetEnLigneMediateur) ; |
} |
else |
{ |
return null ; |
} |
} |
/** |
* envoie au modèle une demande de mise a jour |
*/ |
private EtatConnexionVue etatConnexionVue = null; // Vue Etat de la |
// connexion utilisateur |
private FormulaireDeConnexionVue formulaireDeConnexionVue = null; // Formulaire |
// de |
// connexion |
// utilisateur |
private ListeObservationsVue listeObservationsVue = null; // Liste de |
// releves |
// |
public ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur) { |
this.carnetEnLigneMediateur = carnetEnLigneMediateur; |
etatConnexionVue = new EtatConnexionVue(this); |
listeObservationsVue = new ListeObservationsVue(this); |
VerticalPanel panel = new VerticalPanel(); |
panel.add(etatConnexionVue); |
panel.add(listeObservationsVue); |
RootPanel.get().add(panel); |
onInitialisation(); |
public void obtenirNombreObservation() { |
listeObservation.masquerChargement(); |
observationModele.obtenirNombreObservation(this) ; |
} |
// / Methodes privees |
/** |
* |
* Initialisations |
* |
* envoie au modèle une demande de mise a jour |
*/ |
private void onInitialisation() { |
afficheEtatConnexion(); |
onFiltrageListeObservation("all", "all", "all"); |
public void obtenirListeObservation() { |
observationModele.obtenirListeObservation(this, taillePage, pageEncours) ; |
} |
// Filtre selection lieu |
/** |
* Action sur selection d'un lieu : affichage de la liste des taxons |
* correspondants au filtrage |
* C'est dans cette fonction que doivent être renvoyé les valeurs des filtres |
* sous forme de tableau [nom, valeur] |
* @return Les noms et valeurs des filtres |
*/ |
public String[][] renvoyerFiltres() |
{ |
String[][] valeursFiltres = { {"location","Saint-Martin-de-Londres"} } ; |
return valeursFiltres ; |
} |
public void onFiltrageListeObservation(String id_loc, String loc, |
String lieu) { |
// Positionnement Filtre affichage |
listeObservationsVue.setIdLocation(id_loc); |
listeObservationsVue.setLocalite(loc); |
listeObservationsVue.setLieudit(lieu); |
listeObservationsVue.initialiser(); |
public String getIdentifiant() { |
return carnetEnLigneMediateur.getUtilisateur().getIdentifiant(); |
} |
// Affichage des filtres |
listeObservationsVue.displayFilter(); |
public Panel getPanneauPrincipalObservation() { |
return panneauPrincipalObservation; |
} |
// TODO : plutot dans la listevu non ? |
// / UTILISATEUR |
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()][8]; |
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=(Observation) data.get(it.next()); |
observationData[i][0]= obs.getTransmis(); |
observationData[i][1]= obs.getNomSaisi(); |
observationData[i][2]= obs.getNomRetenu(); |
observationData[i][3]= obs.getLieudit(); |
observationData[i][4]= obs.getDate(); |
observationData[i][5]= obs.getNumeroOrdre(); |
/** |
* Affichage etat de la connexion |
*/ |
i++ ; |
} |
// creation du store qui les contient |
FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
FieldDef defDateObservation = new StringFieldDef("date_observation"); |
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
// on associe le store |
private void afficheEtatConnexion() { |
if (!carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
etatConnexionVue.setEtat(texteDeconnexion, false); |
} else { |
etatConnexionVue.setEtat(carnetEnLigneMediateur.getUtilisateur() |
.getIdentifiant() |
+ " (deconnexion)", true); |
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
defLieuObservation, defDateObservation, defOrdreObservation }; |
RecordDef rd = new RecordDef(defTab); |
final MemoryProxy dataProxy = new MemoryProxy(observationData); |
final ArrayReader reader = new ArrayReader(rd); |
final Store observationStore = new Store(dataProxy, reader); |
st = observationStore ; |
st.load() ; |
// par défaut le store est trié sur l'ordre d'observations |
st.sort("ordre_observation") ; |
// si on doit répandre les données, on notifie le médiateur qui les distribuera à son tour |
if(repandreRafraichissement) |
{ |
listeObservation.rafraichir(st, false) ; |
} |
} |
// 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]) ; |
obtenirListeObservation(); |
} |
} |
/** |
* |
* Affichage boite de connexion |
* |
* 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 afficherDialogueConnexion() { |
// TODO : singleton ? |
formulaireDeConnexionVue = new FormulaireDeConnexionVue(this); |
// Position it roughly in the middle of the screen. |
int left = (Window.getClientWidth() - 512) / 2; |
int top = (Window.getClientHeight() - 256) / 2; |
formulaireDeConnexionVue.setPopupPosition(left, top); |
formulaireDeConnexionVue.show(); |
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) |
{ |
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ; |
listeObservation.getToolBarVue().rafraichir(pages, false) ; |
} |
/** |
* Deconnexion de l'utilisateur en cours |
* 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 void deconnecterUtilisateur() { |
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.DECONNEXION,this); |
carnetEnLigneMediateur.deconnecterUtilisateur(); |
public int calculerNbPages(int nbElements) |
{ |
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement |
// pour eviter qu'il arrondisse mal la division |
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur |
double nPage = (1.0*nbElements)/(1.0*taillePage) ; |
double nPageRound = Math.ceil(nPage) ; |
Double nPageInt = new Double(nPageRound) ; |
// on convertit en entier |
return nPageInt.intValue() ; |
} |
/** |
* Tentative de connexion utilisateur |
* |
* @param login |
* @param password |
* 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 void connecterUtilisateur(String login, String password) { |
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.CONNEXION,this); |
carnetEnLigneMediateur.connecterUtilisateur(login, password); |
public int calculerPageCourante(int nbElements) |
{ |
// on calcule le nombre de page |
int nouvelNbPages = calculerNbPages(nbElements) ; |
// la nouvelle page en cours |
double nPageCourante = (1.0*pageEncours)/(1.0*pageMax) * (1.0*nouvelNbPages) ; |
// on arrondit au supérieur |
double nPageRound = Math.ceil(nPageCourante) ; |
Double nPageInt = new Double(nPageRound) ; |
// on convertit en entier |
return Math.abs(nPageInt.intValue()) ; |
} |
// / OBSERVATION |
/** |
* Recherche nombre d'enregistrement pour l'utilisateur et la localite en |
* cours |
* |
* Appelle le modèle pour lui demander les données d'une page à afficher |
* @param pageCourante le numéro de page à affciher |
*/ |
public void changerNumeroPage(int pageCourante) { |
pageEncours = pageCourante ; |
// On lance le chargerment des observations |
obtenirNombreObservation(); |
listeObservation.getToolBarVue().changerPageCourante(pageCourante); |
} |
/** |
* Appelle le modèle pour qu'il change la taille de page utilisée |
* @param nouvelleTaillePage la nouvelle taille de page |
*/ |
public void changerTaillePage(int nouvelleTaillePage) |
{ |
taillePage = nouvelleTaillePage ; |
pageEncours = calculerPageCourante(nbElements) ; |
public void getNombreObservation(String identifiantLocalite, |
String localite, String annee, String mois, String jour, |
String lieudit, String rechercheLibre) { |
observationModele.getNombreObservation(new iRetourObservation() { |
public void onRetour(Observation obs) { |
observation = obs; |
// fireEvent(NOMBRE_OBSERVATION); |
} |
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), |
identifiantLocalite, localite, annee, mois, jour, lieudit, |
rechercheLibre |
); |
// On lance le chargerment des observations |
obtenirNombreObservation(); |
// et on met à jour la taille de page dans les barres d'outils |
listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage); |
} |
public void getListeObservation(String identifiantLocalite, |
String localite, String annee, String mois, String jour, |
String lieudit, String rechercheLibre, int debut, int longueur) { |
observationModele.getListeObservation(new iRetourObservation() { |
public void onRetour(Observation obs) { |
observation = obs; |
// fireEvent(LISTE_OBSERVATION); |
} |
// Retourne le fournisseur de donnee en referentiel Commune. doit posseder la methode obtenirListeDonnees() |
public FournisseurListe obtenirFournisseurReferentielCommune() { |
return observationModele.obtenirFournisseurReferentielCommune() ; |
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), |
identifiantLocalite, localite, annee, mois, jour, lieudit, |
rechercheLibre, debut, longueur |
); |
} |
public Observation getObservation() { |
return observation; |
} |
// / EVENEMENTS |
/** |
* Evenements |
* |
*/ |
/* |
* public void handleEvent(BaseEvent be) { switch (be.type) { case |
* CarnetEnLigneMediateur.DECONNEXION: afficheEtatConnexion(); break; case |
* CarnetEnLigneMediateur.CONNEXION: if |
* (carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
* formulaireDeConnexionVue.hide(); afficheEtatConnexion(); } else { |
* formulaireDeConnexionVue.afficherMessageAlerte(); // Erreur |
* identification } break; } } |
* |
*/ |
} |
/trunk/src/org/tela_botanica/client/observation/ListeObservationsVue.java |
---|
3,6 → 3,7 |
*/ |
/* |
* ListeObservationsVue.java (Composite de Panel) |
* |
28,6 → 29,7 |
* Suppression d'une liste d'element |
*/ |
/* Actions declenchees : |
* |
* onInventoryItemSelected(numero d'ordre de la ligne selectionne) : selection d'une ligne |
36,27 → 38,34 |
* |
*/ |
package org.tela_botanica.client.observation; |
import org.tela_botanica.client.modeles.Observation; |
import com.google.gwt.user.client.ui.Button; |
import com.google.gwt.user.client.ui.ClickListener; |
import com.google.gwt.user.client.HTTPRequest; |
import com.google.gwt.user.client.ResponseTextHandler; |
import com.google.gwt.user.client.ui.Composite; |
import com.google.gwt.user.client.ui.DockPanel; |
import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
import com.google.gwt.user.client.ui.HasVerticalAlignment; |
import com.google.gwt.user.client.ui.HorizontalPanel; |
import com.google.gwt.user.client.ui.Button; |
import com.google.gwt.user.client.ui.Label; |
import com.google.gwt.user.client.ui.Widget; |
import com.google.gwt.user.client.ui.ClickListener; |
import com.google.gwt.user.client.ui.HasHorizontalAlignment; |
import com.google.gwt.user.client.ui.HasVerticalAlignment; |
public class ListeObservationsVue extends Composite { |
public class ListeObservationsVue extends Composite |
{ |
// Debut Barre de navigation |
private class NavBar extends Composite implements ClickListener { |
public final DockPanel bar = new DockPanel(); |
public final Button gotoFirst = new Button("<<", this); |
public final Button gotoNext = new Button(">", this); |
63,29 → 72,31 |
public final Button gotoPrev = new Button("<", this); |
public final Button gotoEnd = new Button(">>", this); |
public final Label status = new Label(); |
public NavBar() { |
initWidget(bar); |
status.setWordWrap(false); |
HorizontalPanel buttons = new HorizontalPanel(); |
buttons.add(status); |
buttons.setCellHorizontalAlignment(status, |
HasHorizontalAlignment.ALIGN_RIGHT); |
buttons.setCellVerticalAlignment(status, |
HasVerticalAlignment.ALIGN_MIDDLE); |
buttons.setCellHorizontalAlignment(status, HasHorizontalAlignment.ALIGN_RIGHT); |
buttons.setCellVerticalAlignment(status, HasVerticalAlignment.ALIGN_MIDDLE); |
buttons.add(gotoFirst); |
buttons.add(gotoPrev); |
buttons.add(gotoNext); |
buttons.add(gotoEnd); |
bar.add(buttons, DockPanel.EAST); |
} |
public void onClick(Widget sender) { |
if (sender == gotoNext) { |
117,10 → 128,10 |
// Fin Barre de navigation |
// Conteneur (header et table sont dans panel) |
// private ContentPanel panel =null; |
// private Table table = null; |
// Services |
// private ContentPanel panel =null; |
// private Table table = null; |
// Services |
private String serviceBaseUrl = null; |
private String user; |
private ObservationMediateur observationMediateur = null; |
129,10 → 140,10 |
private int startIndex = 0; |
private int count = 0; |
private static final int VISIBLE_TAXON_COUNT = 15; |
private NavBar navBar = null; |
private NavBar navBar=null; |
// Filtre par defaut : |
private String identifiantLocalite = "all"; |
private String localite = "all"; |
private String annee = "all"; |
140,150 → 151,183 |
private String jour = "all"; |
private String rechercheLibre = "all"; |
private String lieudit = "all"; |
private String ordre = null; |
private String ordre= null; |
public ListeObservationsVue(ObservationMediateur observationMediateur) { |
// Traitement contexte utilisateur et service |
this.observationMediateur = observationMediateur; |
this.observationMediateur=observationMediateur; |
// panel= new ContentPanel(Style.HEADER); |
// panel.setLayout(new FillLayout()); |
// panel= new ContentPanel(Style.HEADER); |
// panel.setLayout(new FillLayout()); |
// Barre navigation integree au header |
navBar = new NavBar(); |
// panel.getHeader().addWidget(navBar); |
// Barre navigation integree au header |
// Contenu : |
// Colonnes : |
// TableColumn[] columns = new TableColumn[6]; |
// TODO : renderer date, alignement etc |
/* |
columns[0] = new TableColumn("etat","Transmis", 50); |
navBar = new NavBar(); |
// panel.getHeader().addWidget(navBar); |
columns[1] = new TableColumn("nom","Nom saisi", 250); |
columns[2] = new TableColumn("nomr","Nom retenu", 250); |
// Contenu : |
columns[3] = new TableColumn("lieu","Lieu", 350); |
// Colonnes : |
columns[4] = new TableColumn("date","Date", 75); |
// TableColumn[] columns = new TableColumn[6]; |
columns[5] = new TableColumn("ordre","Ordre", 50); |
TableColumnModel cm = new TableColumnModel(columns); |
// Table : |
table = new Table(Style.MULTI | Style.HORIZONTAL, cm); |
table.setBorders(false); |
panel.add(table); |
// TODO : renderer date, alignement etc |
/* |
* columns[0] = new TableColumn("etat","Aransmis", 50); |
* |
* columns[1] = new TableColumn("nom","Nom saisi", 250); |
* |
* columns[2] = new TableColumn("nomr","Nom retenu", 250); |
* |
* columns[3] = new TableColumn("lieu","Lieu", 350); |
* |
* columns[4] = new TableColumn("date","Date", 75); |
* |
* columns[5] = new TableColumn("ordre","Ordre", 50); |
* |
* |
* TableColumnModel cm = new TableColumnModel(columns); |
* // Table : |
* |
* table = new Table(Style.MULTI | Style.HORIZONTAL, cm); |
* table.setBorders(false); |
* |
* |
* panel.add(table); |
* |
* |
* // Selection d'une ligne table.addListener(Events.RowClick, new |
* Listener() { |
* |
* public void handleEvent(BaseEvent be) { TableItem item=(TableItem) |
* be.item; if (item!=null) { if (ordre==null) { // Affichage de la |
* ligne selectionne ordre= (String) item.getValue(5); // |
* observationMediateur.onInventoryItemSelected(ordre); } else { // Si |
* une ligne etait deja selectionne if (ordre.compareTo((String) |
* item.getValue(5))==0) { // C'est la meme, on la deselectionne |
* ordre=null; table.deselect(be.rowIndex); // |
* observationMediateur.onInventoryItemUnselected(); } else { ordre= |
* (String) item.getValue(5); // C'est une autre, on la selectionne // |
* observationMediateur.onInventoryItemSelected(ordre); } |
* } } } }); |
*/ |
// Selection d'une ligne |
table.addListener(Events.RowClick, new Listener() { |
// initWidget(panel); |
public void handleEvent(BaseEvent be) { |
TableItem item=(TableItem) be.item; |
if (item!=null) { |
if (ordre==null) { // Affichage de la ligne selectionne |
ordre= (String) item.getValue(5); |
// observationMediateur.onInventoryItemSelected(ordre); |
} |
else { |
// Si une ligne etait deja selectionne |
if (ordre.compareTo((String) item.getValue(5))==0) { // C'est la meme, on la deselectionne |
ordre=null; |
table.deselect(be.rowIndex); |
// observationMediateur.onInventoryItemUnselected(); |
} |
else { |
ordre= (String) item.getValue(5); // C'est une autre, on la selectionne |
// observationMediateur.onInventoryItemSelected(ordre); |
} |
} |
} |
} |
}); |
*/ |
// initWidget(panel); |
} |
/** |
* Suppression d'un ensemble d'element de la liste d'inventaire, on garde |
* ici car s'applique a plusieurs elements |
* Suppression d'un ensemble d'element de la liste d'inventaire, on garde ici car s'applique a plusieurs elements |
* |
*/ |
public void deleteElement() { |
/* |
* setStatusDisabled(); TableItem[] selection=table.getSelection(); |
* |
* StringBuffer ids=new StringBuffer(); for (int i = 0; i < |
* selection.length; i++) { ids.append((String)(((TableItem) |
* selection[i]).getValue(5))); if (i<(selection.length-1)) |
* ids.append(","); } |
* |
* if (ids.length()>0) { |
* |
* HTTPRequest.asyncPost(serviceBaseUrl + "/Inventory/" + user + "/" + |
* ids.toString(), "action=DELETE", |
* |
* new ResponseTextHandler() { public void onCompletion(String str) { // |
* observationMediateur.onInventoryUpdated(identifiantLocalite,"all","all"); // |
* observationMediateur.getEntryView().clear(); } }); } |
* |
* setStatusEnabled(); |
*/ |
/* |
setStatusDisabled(); |
TableItem[] selection=table.getSelection(); |
StringBuffer ids=new StringBuffer(); |
for (int i = 0; i < selection.length; i++) { |
ids.append((String)(((TableItem) selection[i]).getValue(5))); |
if (i<(selection.length-1)) ids.append(","); |
} |
if (ids.length()>0) { |
HTTPRequest.asyncPost(serviceBaseUrl + "/Inventory/" + user |
+ "/" + ids.toString(), "action=DELETE", |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
// observationMediateur.onInventoryUpdated(identifiantLocalite,"all","all"); |
// observationMediateur.getEntryView().clear(); |
} |
}); |
} |
setStatusEnabled(); |
*/ |
} |
/** |
* Transmission de releve a Tela, on garde ici car s'applique a plusieurs |
* elements |
* Transmission de releve a Tela, on garde ici car s'applique a plusieurs elements |
*/ |
public void transmitElement() { |
setStatusDisabled(); |
/* TableItem[] selection=table.getSelection(); |
/* |
* TableItem[] selection=table.getSelection(); |
* |
* StringBuffer ids=new StringBuffer(); for (int i = 0; i < |
* selection.length; i++) { ids.append((String)(((TableItem) |
* selection[i]).getValue(5))); if (i<(selection.length-1)) |
* ids.append(","); } |
* |
* if (ids.length()>0) { |
* |
* HTTPRequest.asyncPost(serviceBaseUrl + "/InventoryTransmit/" + user + |
* "/" + ids.toString(), "transmission=1", |
* |
* new ResponseTextHandler() { public void onCompletion(String str) { |
* getListeObservation(); // Pour affichage logo } }); } |
* |
* setStatusEnabled(); |
* |
*/ |
StringBuffer ids=new StringBuffer(); |
for (int i = 0; i < selection.length; i++) { |
ids.append((String)(((TableItem) selection[i]).getValue(5))); |
if (i<(selection.length-1)) ids.append(","); |
} |
if (ids.length()>0) { |
HTTPRequest.asyncPost(serviceBaseUrl + "/InventoryTransmit/" + user |
+ "/" + ids.toString(), "transmission=1", |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
getListeObservation(); // Pour affichage logo |
} |
}); |
} |
setStatusEnabled(); |
*/ |
} |
/** |
* Recherche nombre d'enregistrement pour l'utilisateur et la localite en |
* cours |
* Recherche nombre d'enregistrement pour l'utilisateur et la localite en cours |
* |
*/ |
public void initialiser() { |
setStatusDisabled(); |
// observationMediateur.addListener(ObservationMediateur.NOMBRE_OBSERVATION,this); |
observationMediateur.getNombreObservation(identifiantLocalite, |
localite, annee, mois, jour, lieudit, rechercheLibre); // Retour |
// dans |
// handlevent() |
// NOMBRE_OBSERVATION |
// observationMediateur.addListener(ObservationMediateur.NOMBRE_OBSERVATION,this); |
// observationMediateur.getNombreObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre); // Retour dans handlevent() NOMBRE_OBSERVATION |
} |
/** |
* Mise a jour de l'affichage, a partir des donnaes d'inventaire deja |
* saisies. La valeur de this.startIndex permet de determiner quelles |
293,189 → 337,264 |
public void getListeObservation() { |
// observationMediateur.addListener(ObservationMediateur.LISTE_OBSERVATION,this); |
observationMediateur.getListeObservation(identifiantLocalite, localite, |
annee, mois, jour, lieudit, rechercheLibre, startIndex, |
VISIBLE_TAXON_COUNT); // Retour dans handlevent() |
// LISTE_OBSERVATION |
// observationMediateur.addListener(ObservationMediateur.LISTE_OBSERVATION,this); |
// observationMediateur.getListeObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre, startIndex, VISIBLE_TAXON_COUNT); // Retour dans handlevent() LISTE_OBSERVATION |
} |
public void afficherListeObservation() { |
Observation[] listeObservation = observationMediateur.getObservation() |
.getListeObservation(); |
// Observation[] listeObservation =observationMediateur.getObservation().getListeObservation(); |
/* |
for (int i=0;i<listeObservation.length;i++) { |
Object[] values = new Object[6]; |
values[0]="0"; |
values[2]="2"; |
values[3]="3"; |
values[4]="4"; |
values[5]="5"; |
values[1]=listeObservation[i].getNomSaisi(); |
*/ |
// table.add(new TableItem(values)); |
} |
// Ligne d'information |
for (int i = 0; i < listeObservation.length; i++) { |
// Toutes date par defaut |
/* |
Object[] values = new Object[6]; |
values[0] = "0"; |
values[2] = "2"; |
values[3] = "3"; |
values[4] = "4"; |
values[5] = "5"; |
values[1] = listeObservation[i].getNomSaisi(); |
HTTPRequest.asyncGet(serviceBaseUrl + "/InventoryItemList/" + user + "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) +"/" + annee + "/" + mois + "/" + jour + "/" + URL.encodeComponent(rechercheLibre) + "/" + URL.encodeComponent(lieudit) + "/" |
+ startIndex + "/" + VISIBLE_TAXON_COUNT, |
// table.add(new TableItem(values)); |
new ResponseTextHandler() { |
} |
public void onCompletion(String str) { |
// Ligne d'information |
JSONValue jsonValue = JSONParser.parse(str); |
JSONArray jsonArray; |
JSONArray jsonArrayNested; |
int i=0; |
// Toutes date par defaut |
if ((jsonArray = jsonValue.isArray()) != null) { |
StringBuffer lieu=null; |
int arraySize = jsonArray.size(); |
for (i = 0; i < arraySize; ++i) { |
if ((jsonArrayNested = jsonArray.get(i).isArray()) != null) { |
Object[] values = new Object[6]; |
// Statut Observation transmise ? |
String atransmit=((JSONString) jsonArrayNested .get(13)).stringValue(); |
if (atransmit.compareTo("1")==0) { |
values[0] = new Image("tela.gif"); |
} |
else { |
values[0] = new HTML(" "); |
} |
// Nom saisi |
values[1] = new HTML("<b>"+Util.toCelString(((JSONString) jsonArrayNested .get(0)).toString())+"</b>"); |
// Nom retenu |
String aname=Util.toCelString(((JSONString) jsonArrayNested .get(2)).toString()); |
if (aname.compareTo("null")==0) { |
values[2] = new HTML(" "); |
} |
else { |
values[2] = new HTML(aname); |
} |
/* |
/* |
// Num nomenclatural |
String ann=((JSONString) jsonArrayNested .get(3)).stringValue(); |
if (ann.compareTo("0")!=0) { |
observationText.append(""+ann+"-"); |
} |
else { |
observationText.append("0-"); |
} |
// Num Taxonomique |
String ant=((JSONString) jsonArrayNested .get(4)).stringValue(); |
if (ant.compareTo("0")!=0) { |
observationText.append(ant+", "); |
} |
else { |
observationText.append("0, "); |
} |
// Famille |
String afamily=Util.toCelString(((JSONString) jsonArrayNested .get(5)).toString()); |
if (afamily.compareTo("null")==0) { |
// |
} |
else { |
observationText.append(afamily+", "); |
} |
*/ |
/* |
* |
* HTTPRequest.asyncGet(serviceBaseUrl + "/InventoryItemList/" + user + |
* "/" + identifiantLocalite + "/" + URL.encodeComponent(localite) +"/" + |
* annee + "/" + mois + "/" + jour + "/" + |
* URL.encodeComponent(rechercheLibre) + "/" + |
* URL.encodeComponent(lieudit) + "/" + startIndex + "/" + |
* VISIBLE_TAXON_COUNT, |
* |
* new ResponseTextHandler() { |
* |
* public void onCompletion(String str) { |
* |
* JSONValue jsonValue = JSONParser.parse(str); JSONArray jsonArray; |
* JSONArray jsonArrayNested; |
* |
* int i=0; |
* |
* if ((jsonArray = jsonValue.isArray()) != null) { |
* |
* StringBuffer lieu=null; |
* |
* int arraySize = jsonArray.size(); |
* |
* for (i = 0; i < arraySize; ++i) { if ((jsonArrayNested = |
* jsonArray.get(i).isArray()) != null) { |
* |
* |
* Object[] values = new Object[6]; |
* |
* // Statut Observation transmise ? |
* |
* String atransmit=((JSONString) jsonArrayNested |
* .get(13)).stringValue(); |
* |
* if (atransmit.compareTo("1")==0) { values[0] = new Image("tela.gif"); } |
* else { values[0] = new HTML(" "); } |
* |
* // Nom saisi |
* |
* values[1] = new HTML("<b>"+Util.toCelString(((JSONString) |
* jsonArrayNested .get(0)).toString())+"</b>"); |
* |
* |
* // Nom retenu String aname=Util.toCelString(((JSONString) |
* jsonArrayNested .get(2)).toString()); |
* |
* if (aname.compareTo("null")==0) { values[2] = new HTML(" "); } |
* else { values[2] = new HTML(aname); } /* |
* /* // Num nomenclatural String ann=((JSONString) jsonArrayNested |
* .get(3)).stringValue(); |
* |
* if (ann.compareTo("0")!=0) { observationText.append(""+ann+"-"); } |
* else { observationText.append("0-"); } |
* |
* // Num Taxonomique |
* |
* String ant=((JSONString) jsonArrayNested .get(4)).stringValue(); |
* |
* if (ant.compareTo("0")!=0) { observationText.append(ant+", "); } else { |
* observationText.append("0, "); } |
* // Famille |
* |
* |
* String afamily=Util.toCelString(((JSONString) jsonArrayNested |
* .get(5)).toString()); |
* |
* if (afamily.compareTo("null")==0) { // } else { |
* observationText.append(afamily+", "); } |
*/ |
/* |
* // Localisation - Lieu |
* |
* lieu=new StringBuffer(); |
* |
* String aloc=Util.toCelString(((JSONString) jsonArrayNested |
* .get(6)).toString()); |
* |
* if (aloc.compareTo("000null")==0) { if (lieu.length()==0) { |
* lieu.append("Commune absente"); } else { lieu.append("commune |
* absente"); } } else { if (lieu.length()==0) { lieu.append("Commune de |
* "+aloc); } else { lieu.append("commune de "+aloc); } |
* } |
* |
* |
* String alieudit=Util.toCelString(((JSONString) jsonArrayNested |
* .get(9)).toString()); |
* // Localisation - Lieu dit |
* |
* if (alieudit.compareTo("000null")!=0) { lieu.append(", "+alieudit); } |
* |
* // Station - |
* |
* String astation=Util.toCelString(((JSONString) jsonArrayNested |
* .get(10)).toString()); |
* |
* |
* if (astation.compareTo("000null")!=0) { lieu.append(", "+astation); } |
* |
* // Milieu |
* |
* String amilieu=Util.toCelString(((JSONString) jsonArrayNested |
* .get(11)).toString()); |
* |
* |
* if (amilieu.compareTo("000null")!=0) { lieu.append(", "+amilieu); } |
* |
* String acomment=Util.toCelString(((JSONString) jsonArrayNested |
* .get(12)).toString()); // Commentaire |
* |
* if (acomment.compareTo("null")!=0) { lieu.append(", "+acomment); } |
* |
* |
* if (lieu.toString().compareTo("")==0) { values[3] = new |
* HTML(" "); } else { values[3] = new HTML(lieu.toString()); } |
* |
* |
* String adate=((JSONString) jsonArrayNested .get(8)).stringValue(); |
* // Date if (adate.compareTo("0000-00-00 00:00:00")!=0) { |
* values[4]=new HTML("<b>"+adate+"</b>"); } else { values[4] = new |
* HTML(" "); } |
* |
* |
* |
* String aordre=((JSONString) jsonArrayNested.get(7)).stringValue(); |
* // Numero d'ordre (cache) |
* |
* values[5] = aordre; |
* |
* |
* |
* |
* if (i>=table.getItemCount()) { TableItem item = new |
* TableItem(values); table.add(item); } else { TableItem |
* item=table.getItem(i); item.setValue(0,values[0]); |
* item.setValue(1,values[1]); item.setValue(2,values[2]); |
* item.setValue(3,values[3]); item.setValue(4,values[4]); |
* item.setValue(5,values[5]); } |
* // Spagetti if (ordre!=null) { if (aordre.compareTo(ordre)==0) { |
* table.select(i); } else { table.deselect(i); } } |
* } |
* } } |
* // Suppression fin ancien affichage if (i<table.getItemCount()) { |
* for (int j = table.getItemCount() -1 ; j >= i; j--) { TableItem |
* item=table.getItem(j); table.remove(item); } } |
* |
* setStatusEnabled(); |
* |
* } }); |
*/ |
// Localisation - Lieu |
} |
lieu=new StringBuffer(); |
String aloc=Util.toCelString(((JSONString) jsonArrayNested .get(6)).toString()); |
if (aloc.compareTo("000null")==0) { |
if (lieu.length()==0) { |
lieu.append("Commune absente"); |
} |
else { |
lieu.append("commune absente"); |
} |
} |
else { |
if (lieu.length()==0) { |
lieu.append("Commune de "+aloc); |
} |
else { |
lieu.append("commune de "+aloc); |
} |
} |
String alieudit=Util.toCelString(((JSONString) jsonArrayNested .get(9)).toString()); |
// Localisation - Lieu dit |
if (alieudit.compareTo("000null")!=0) { |
lieu.append(", "+alieudit); |
} |
// Station - |
String astation=Util.toCelString(((JSONString) jsonArrayNested .get(10)).toString()); |
if (astation.compareTo("000null")!=0) { |
lieu.append(", "+astation); |
} |
// Milieu |
String amilieu=Util.toCelString(((JSONString) jsonArrayNested .get(11)).toString()); |
if (amilieu.compareTo("000null")!=0) { |
lieu.append(", "+amilieu); |
} |
String acomment=Util.toCelString(((JSONString) jsonArrayNested .get(12)).toString()); |
// Commentaire |
if (acomment.compareTo("null")!=0) { |
lieu.append(", "+acomment); |
} |
if (lieu.toString().compareTo("")==0) { |
values[3] = new HTML(" "); |
} |
else { |
values[3] = new HTML(lieu.toString()); |
} |
String adate=((JSONString) jsonArrayNested .get(8)).stringValue(); |
// Date |
if (adate.compareTo("0000-00-00 00:00:00")!=0) { |
values[4]=new HTML("<b>"+adate+"</b>"); |
} |
else { |
values[4] = new HTML(" "); |
} |
String aordre=((JSONString) jsonArrayNested.get(7)).stringValue(); |
// Numero d'ordre (cache) |
values[5] = aordre; |
if (i>=table.getItemCount()) { |
TableItem item = new TableItem(values); |
table.add(item); |
} |
else { |
TableItem item=table.getItem(i); |
item.setValue(0,values[0]); |
item.setValue(1,values[1]); |
item.setValue(2,values[2]); |
item.setValue(3,values[3]); |
item.setValue(4,values[4]); |
item.setValue(5,values[5]); |
} |
// Spagetti |
if (ordre!=null) { |
if (aordre.compareTo(ordre)==0) { |
table.select(i); |
} |
else { |
table.deselect(i); |
} |
} |
} |
} |
} |
// Suppression fin ancien affichage |
if (i<table.getItemCount()) { |
for (int j = table.getItemCount() -1 ; j >= i; j--) { |
TableItem item=table.getItem(j); |
table.remove(item); |
} |
} |
setStatusEnabled(); |
} |
}); |
*/ |
// } |
/** |
* Affichage message d'attente et desactivation navigation |
* |
505,20 → 624,18 |
if (count > 0) { |
if (startIndex >= VISIBLE_TAXON_COUNT) { // Au dela de la |
// premiere page |
// premiere page |
navBar.gotoPrev.setEnabled(true); |
navBar.gotoFirst.setEnabled(true); |
if (startIndex < (count - VISIBLE_TAXON_COUNT)) { // Pas la |
// derniere |
// page |
// derniere |
// page |
navBar.gotoNext.setEnabled(true); |
navBar.gotoEnd.setEnabled(true); |
navBar.status.setText((startIndex + 1) + " - " |
+ (startIndex + VISIBLE_TAXON_COUNT) + " sur " |
+ count); |
+ (startIndex + VISIBLE_TAXON_COUNT) + " sur " + count ); |
} else { // Derniere page |
navBar.status.setText((startIndex + 1) + " - " + count |
+ " sur " + count); |
navBar.status.setText((startIndex + 1) + " - " + count + " sur " + count ); |
} |
} else { // Premiere page |
if (count > VISIBLE_TAXON_COUNT) { // Des pages derrieres |
525,11 → 642,9 |
navBar.gotoNext.setEnabled(true); |
navBar.gotoEnd.setEnabled(true); |
navBar.status.setText((startIndex + 1) + " - " |
+ (startIndex + VISIBLE_TAXON_COUNT) + " sur " |
+ count); |
+ (startIndex + VISIBLE_TAXON_COUNT) + " sur " + count); |
} else { |
navBar.status.setText((startIndex + 1) + " - " + count |
+ " sur " + count); |
navBar.status.setText((startIndex + 1) + " - " + count + " sur " + count); |
} |
} |
} |
543,7 → 658,8 |
* Positionnement index de parcours (this.startIndex) pour affichage de la |
* derniere page |
* |
* @param @return void |
* @param |
* @return void |
*/ |
private void gotoEnd() { |
560,31 → 676,37 |
* Recherche en cours |
* |
*/ |
public void setRechercheLibre(String search) { |
this.rechercheLibre = search; |
} |
/* |
* Departement en cours |
* Departement en cours |
* |
*/ |
public void setIdLocation(String id_location) { |
this.identifiantLocalite = id_location; |
} |
/* |
* Localite en cours |
* Localite en cours |
* |
*/ |
public void setLocalite(String location) { |
this.localite = location; |
} |
/* |
* Lieudit en cours |
* Lieudit en cours |
* |
*/ |
592,15 → 714,19 |
this.lieudit = lieudit; |
} |
/* |
* Date en cours |
* Date en cours |
* |
*/ |
public void setAnnee(String year) { |
this.annee = year; |
} |
public void setMois(String month) { |
this.mois = month; |
} |
609,144 → 735,187 |
this.jour = day; |
} |
/* |
* Utilisateur en cours |
* Utilisateur en cours |
* |
*/ |
public void setUser(String user) { |
this.user = user; |
} |
public void displayFilter() { |
// Mise a jour boutton export feuille de calcul |
// Mise a jour boutton export feuille de calcul |
/* |
* observationMediateur.getActionView().getExportButton().setHTML("<a |
* href=\""+observationMediateur.getServiceBaseUrl()+"/InventoryExport/" + |
* user + "/" + URL.encodeComponent(identifiantLocalite) + "/" + |
* URL.encodeComponent(localite) + "/" + URL.encodeComponent(lieudit)+ |
* "/" + annee + "/" + mois + "/" + jour + "\">"+"Export tableur</a>"); |
* |
*/ |
// Mise a jour ligne de selection |
observationMediateur.getActionView().getExportButton().setHTML("<a href=\""+observationMediateur.getServiceBaseUrl()+"/InventoryExport/" |
+ user + "/" |
+ URL.encodeComponent(identifiantLocalite) + "/" |
+ URL.encodeComponent(localite) + "/" |
+ URL.encodeComponent(lieudit)+ "/" |
+ annee + "/" |
+ mois + "/" |
+ jour |
+ "\">"+"Export tableur</a>"); |
String dep; |
if (identifiantLocalite.compareTo("all") == 0) { |
dep = "Tous départements"; |
} else { |
if (identifiantLocalite.compareTo("000null") == 0) { |
dep = "Départements non renseignées "; |
} else { |
dep = "Département " + identifiantLocalite; |
} |
*/ |
// Mise a jour ligne de selection |
String dep; |
if (identifiantLocalite.compareTo("all")==0) { |
dep="Tous départements"; |
} |
else { |
if (identifiantLocalite.compareTo("000null")==0) { |
dep="Départements non renseignées "; |
} |
String com; |
if (localite.compareTo("all") == 0) { |
com = ", toutes communes"; |
} else { |
if (localite.compareTo("000null") == 0) { |
com = ", communes non renseignées"; |
} else { |
com = ", commune de " + localite; |
} |
else { |
dep="Département "+identifiantLocalite; |
} |
String lieu; |
if (lieudit.compareTo("all") == 0) { |
lieu = ", tous lieux dits"; |
} else { |
if (lieudit.compareTo("000null") == 0) { |
lieu = ", lieu-dit non renseignées"; |
} else { |
lieu = ", lieu-dit " + lieudit; |
} |
} |
String com; |
if (localite.compareTo("all")==0) { |
com=", toutes communes"; |
} |
else { |
if (localite.compareTo("000null")==0) { |
com=", communes non renseignées"; |
} |
else { |
com=", commune de "+localite; |
} |
} |
String dat; |
if ((annee.compareTo("all") == 0) && (mois.compareTo("all") == 0) |
&& (jour.compareTo("all") == 0)) { |
dat = ", toutes periodes"; |
String lieu; |
if (lieudit.compareTo("all")==0) { |
lieu=", tous lieux dits"; |
} |
else { |
if (lieudit.compareTo("000null")==0) { |
lieu=", lieu-dit non renseignées"; |
} |
else { |
lieu=", lieu-dit "+ lieudit; |
} |
} |
String dat; |
if ((annee.compareTo("all")==0) && (mois.compareTo("all")==0) && (jour.compareTo("all")==0)) { |
dat=", toutes periodes"; |
} |
else { |
String yea=""; |
String da=""; |
String mont=""; |
if (annee.compareTo("all")==0) { |
yea=", toutes années"; |
} |
else { |
if (annee.compareTo("0")==0) { |
yea=", periode non renseignée"; |
} |
else { |
yea=", "+ annee; |
if (mois.compareTo("all")==0) { |
mont=", tous mois"; |
} |
else { |
mont="/"+ mois; |
} |
if (jour.compareTo("all")==0) { |
da=", tous jours"; |
} |
else { |
da="/"+ jour; |
} |
} |
} |
dat=yea + mont + da; |
} |
String yea = ""; |
String da = ""; |
String mont = ""; |
//panel.getHeader().setText(dep + com + lieu + dat); |
if (annee.compareTo("all") == 0) { |
yea = ", toutes années"; |
} else { |
if (annee.compareTo("0") == 0) { |
yea = ", periode non renseignée"; |
} else { |
yea = ", " + annee; |
if (mois.compareTo("all") == 0) { |
mont = ", tous mois"; |
} else { |
mont = "/" + mois; |
} |
} |
if (jour.compareTo("all") == 0) { |
da = ", tous jours"; |
} else { |
da = "/" + jour; |
} |
} |
} |
dat = yea + mont + da; |
/// EVENEMENTS |
/** |
* Evenements |
* |
*/ |
/* |
public void handleEvent(BaseEvent be) { |
switch (be.type) { |
case ObservationMediateur.NOMBRE_OBSERVATION: |
gotoEnd(); |
getListeObservation(); |
break; |
case ObservationMediateur.LISTE_OBSERVATION: |
afficherListeObservation(); |
break; |
} |
// panel.getHeader().setText(dep + com + lieu + dat); |
} |
*/ |
// / EVENEMENTS |
/** |
* Evenements |
* |
*/ |
/* |
* public void handleEvent(BaseEvent be) { switch (be.type) { case |
* ObservationMediateur.NOMBRE_OBSERVATION: gotoEnd(); |
* getListeObservation(); break; case |
* ObservationMediateur.LISTE_OBSERVATION: afficherListeObservation(); |
* break; } } |
*/ |
} |
/* |
* +--Fin du code |
* ---------------------------------------------------------------------------------------+ |
* $Log: not supported by cvs2svn $ Revision 1.1 2008-09-19 10:27:18 |
* aperonnet Carnet en ligne, utilisant gwt 1.5 et la nouvelle version de |
* gwt-ext (plus de bugs au demarrage dans firefox, plus rapide et annotations |
* java) |
* |
* Revision 1.3 2008-06-17 14:16:16 aperonnet *** empty log message *** |
* |
* Revision 1.2 2008-06-09 16:29:01 ddelon import branche observation |
* |
* Revision 1.1 2008-06-09 14:19:37 ddelon Initialisation observation |
* |
* Revision 1.3 2008-04-28 13:10:43 ddelon Integration MyGwt |
* |
* Revision 1.2 2008-01-30 08:55:40 ddelon fin mise en place mygwt |
* |
* Revision 1.1 2008-01-02 21:26:04 ddelon mise en place mygwt |
* |
* Revision 1.8 2007-12-22 14:48:53 ddelon Documentation et refactorisation |
* |
* Revision 1.7 2007-09-17 19:25:34 ddelon Documentation |
* |
*/ |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log$ |
* Revision 1.4 2008-11-13 11:27:05 ddelon |
* Reecriture gwt-ext |
* |
* Revision 1.3 2008-06-17 14:16:16 aperonnet |
* *** empty log message *** |
* |
* Revision 1.2 2008-06-09 16:29:01 ddelon |
* import branche observation |
* |
* Revision 1.1 2008-06-09 14:19:37 ddelon |
* Initialisation observation |
* |
* Revision 1.3 2008-04-28 13:10:43 ddelon |
* Integration MyGwt |
* |
* Revision 1.2 2008-01-30 08:55:40 ddelon |
* fin mise en place mygwt |
* |
* Revision 1.1 2008-01-02 21:26:04 ddelon |
* mise en place mygwt |
* |
* Revision 1.8 2007-12-22 14:48:53 ddelon |
* Documentation et refactorisation |
* |
* Revision 1.7 2007-09-17 19:25:34 ddelon |
* Documentation |
* |
*/ |
/trunk/src/org/tela_botanica/client/observation/ObservationModele.java |
---|
1,40 → 1,137 |
package org.tela_botanica.client.observation; |
import org.tela_botanica.client.interfaces.iRetourObservation; |
import org.tela_botanica.client.modeles.ObservationAsynchroneDAO; |
import com.google.gwt.i18n.client.Dictionary; |
public class ObservationModele { |
import org.tela_botanica.client.interfaces.FournisseurListe; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.Configuration; |
import org.tela_botanica.client.modeles.ListeObservationAsynchroneDAO; |
import org.tela_botanica.client.modeles.ListeReferentielCommuneAsynchroneDAO; |
import org.tela_botanica.client.modeles.NombreObservationAsynchroneDAO; |
private final String baseURL; |
public ObservationModele() { |
public class ObservationModele { |
baseURL = Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
/** |
* Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static) |
*/ |
private static boolean estInstancie = false ; |
/** |
* La configuration en cours |
*/ |
private Configuration config = null; |
/** |
* Le médiateur associé au modèle |
*/ |
private ObservationMediateur observationMediateur = null ; |
/** |
* Retourne une instance de manière unique |
* @param im le médiateur à associer |
* @return l'instance du modèle |
*/ |
static ObservationModele Instance(ObservationMediateur observationMediateur) |
{ |
// si le modèle n'est pas encore instancié |
if(!estInstancie) |
{ |
// on en crée un nouveau |
estInstancie = true ; |
return new ObservationModele(observationMediateur); |
} |
else |
{ |
// sinon on renvoit null, interdisant explicitement la création d'un autre exemplaire |
return null ; |
} |
} |
public void getNombreObservation(final iRetourObservation retour, |
String identifiant, String identifiantLocalite, String localite, |
String annee, String mois, String jour, String lieudit, |
String rechercheLibre) { |
private ObservationModele(ObservationMediateur observationMediateur) { |
this.observationMediateur=observationMediateur; |
config = new Configuration(); |
new ObservationAsynchroneDAO().getNombreObservation(baseURL, retour, |
identifiant, identifiantLocalite, localite, annee, mois, jour, |
lieudit, rechercheLibre); |
} |
/** |
* Appelle le DAO asynchrone pour obtenir le nombre d'observation |
* @param r le rafraichissable auxquel on enverra les données |
* @param taillePage |
*/ |
public void obtenirNombreObservation(Rafraichissable r) { |
String motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ; |
// on rassemble les critères |
String[][] criteres = {{motsClesFiltres[0][0], motsClesFiltres[0][1]} } ; |
// on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages) |
NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ; |
noaDAO.obtenirNombreObservation(r, observationMediateur.getIdentifiant(), criteres) ; |
} |
/** |
* Appelle le DAO asynchrone pour obtenir la liste des images |
* @param r le rafraichissable auxquel on enverra les données |
* @param taillePage |
*/ |
public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) { |
String motsClesFiltres[][] = observationMediateur.renvoyerFiltres() ; |
// ensuite on demande la page correspondante avec les mêmes critères |
String[][] criteres2 = { {"limite" ,""+taillePage },{"numero_page",""+pageEncours}, {motsClesFiltres[0][0], motsClesFiltres[0][1]}} ; |
// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images |
ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this); |
loaDAO.obtenirListeObservation(r, observationMediateur.getIdentifiant(), criteres2); |
} |
public void getListeObservation(iRetourObservation retour, |
String identifiant, String identifiantLocalite, String localite, |
String annee, String mois, String jour, String lieudit, |
String rechercheLibre, int debut, int longueur) { |
public FournisseurListe obtenirFournisseurReferentielCommune() { |
return new ListeReferentielCommuneAsynchroneDAO(this); |
} |
new ObservationAsynchroneDAO().getListeObservation(baseURL, retour, |
identifiant, identifiantLocalite, localite, annee, mois, jour, |
lieudit, rechercheLibre, debut, longueur); |
/** |
* Accesseur pour la configuration en cours d'utilisation |
* |
* @return la configuration |
*/ |
public Configuration getConfig() { |
return config; |
} |
} |
/trunk/src/org/tela_botanica/client/CarnetEnLigneMediateur.java |
---|
1,91 → 1,193 |
package org.tela_botanica.client; |
import org.tela_botanica.client.image.ImageMediateur; |
import org.tela_botanica.client.interfaces.iRetourUtilisateur; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.Utilisateur; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import org.tela_botanica.client.vues.EtatConnexionVue; |
import org.tela_botanica.client.vues.FormulaireDeConnexionVue; |
public class CarnetEnLigneMediateur { |
import com.google.gwt.user.client.Window; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.layout.VerticalLayout; |
// Evenenements |
final static public int ETAT_CONNEXION = 1; |
final static public int DECONNEXION = 2; |
final static public int CONNEXION = 3; |
/** |
* Mediateur gérant les interactions entre vues et les echanges de données |
* C'est un singleton. |
* @author david delon |
* |
*/ |
private final CarnetEnLigneModele carnetEnLigneModele; |
private Utilisateur utilisateur = null; |
public class CarnetEnLigneMediateur implements Rafraichissable { |
/** |
* booleen qui verifie l'unicite de l'instance |
*/ |
private static boolean estInstancie = false ; |
/** |
* modele de données |
*/ |
private CarnetEnLigneModele carnetEnLigneModele=null; |
// Fonctionnement servicecs |
private boolean async = true; |
/** |
* panneau principal de l'application "Carnet en ligne" |
*/ |
public CarnetEnLigneMediateur() { |
private Panel panneauPrincipalCarnetEnLigne=new Panel("Carnet en ligne"); |
/** |
* panneau a onglet pour les observation et les images |
*/ |
private Panel ongletsObservationsImages=null; |
/** |
* Indicateur d'etat de la connexion utilisateur |
*/ |
private EtatConnexionVue etatConnexionVue=null; |
carnetEnLigneModele = new CarnetEnLigneModele(); |
// addListener(ETAT_CONNEXION,this); |
getEtatUtilisateur(); // Alimente Objet Utilisateur |
/** |
* Texte d'invite connexion |
*/ |
private final String texteDeconnexion="Utilisez ce carnet en ligne pour saisir vos observations, <u>identifiez-vous</u> pour les transmettre à Tela Botanica"; |
} |
/** |
* Boolean indiquant un essai de connexion |
*/ |
private boolean tentativeConnection=false; |
/** |
* Fin construction (est appelle sur reception evenement Applicatif |
* ETAT_CONNEXION) |
* |
* Formulaire de connexion (lazy instantiation) |
* |
*/ |
private FormulaireDeConnexionVue formulaireDeConnexionVue=null; |
private void _CarnetEnLigneMediateur() { |
/** |
* Mediateur Gestion des images |
*/ |
private ImageMediateur imageMediateur=null; |
/** |
* Mediateur Gestion des observations |
*/ |
private ObservationMediateur observationMediateur=null; |
ImageMediateur.Instance(); |
new ObservationMediateur(this); |
} |
/** |
* Utilisateur en cours |
*/ |
private void getEtatUtilisateur() { // Pourrait devenir publique ... |
private Utilisateur utilisateur=null; |
// TODO : utiliser une factory ici : Avec Modele synchrone ou non, ou au |
// niveau methode comme dans cette exemple |
public static CarnetEnLigneMediateur Instance() |
{ |
if(!estInstancie) |
{ |
estInstancie = true ; |
return new CarnetEnLigneMediateur() ; |
} |
else |
{ |
return null ; |
} |
} |
/** |
* constructeur privé (on accède a la classe par la méthode getInstance |
*/ |
private CarnetEnLigneMediateur() { |
// Disposition |
panneauPrincipalCarnetEnLigne.setLayout(new VerticalLayout()); |
// Pas possible de traiter dans Modele car retour asynchrone devant etre |
// traité ici. |
// On crée un modèle d'acces aux donnnes |
carnetEnLigneModele=CarnetEnLigneModele.Instance(); |
// La vue affichant le statut de la connexion |
// if asynchrone |
etatConnexionVue=new EtatConnexionVue(this); |
if (async) { |
carnetEnLigneModele |
.getUtilisateurAsynchroneDAO(new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur = uti; |
// fireEvent(ETAT_CONNEXION); |
} |
// Le panneau à onglet qui contient les 2 applications Observation et Images |
ongletsObservationsImages = new Panel(); |
panneauPrincipalCarnetEnLigne.add(etatConnexionVue); |
} |
// on ajoute le panneau a onglet au panneau principal |
panneauPrincipalCarnetEnLigne.add(ongletsObservationsImages); |
); |
// On ajoute les applications |
observationMediateur = ObservationMediateur.Instance(this); |
// imageMediateur= ImageMediateur.Instance(); |
} |
// else if synchrone |
else { |
utilisateur = carnetEnLigneModele.getUtilisateurSynchroneDAO(); |
_CarnetEnLigneMediateur(); |
} |
// on ajoute les panneaux principaux des applications au panneau à onglets |
// ongletsObservationsImages.add(imageMediateur.getPanneauPrincipalImage()); |
ongletsObservationsImages.add(observationMediateur.getPanneauPrincipalObservation()); |
} |
public void getEtatUtilisateur() { |
carnetEnLigneModele.getEtatUtilisateur(this); |
} |
// Evenenements Applicatifs |
/* |
* public void handleEvent(BaseEvent be) { if |
* (be.type==CarnetEnLigneMediateur.ETAT_CONNEXION) { |
* _CarnetEnLigneMediateur(); // Fin initialisation } } |
*/ |
// Methode publiques |
/** |
* Recherche Identifiant utilisateur en cours et etat de connection |
* |
* @return Utilisateur |
*/ |
public Utilisateur getUtilisateur() { |
return utilisateur; |
} |
93,32 → 195,105 |
/** |
* Deconnecte l'utilisateur passe en parametre |
*/ |
public void deconnecterUtilisateur() { |
public void deconnecterUtilisateur() { |
carnetEnLigneModele.deconnecterUtilisateur(new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur = uti; |
// fireEvent(DECONNEXION); |
} |
carnetEnLigneModele.deconnecterUtilisateur(this, utilisateur.getIdentifiant()); |
}, utilisateur.getIdentifiant() |
} |
); |
public void connecterUtilisateur(String login, String password) { |
tentativeConnection=true; |
carnetEnLigneModele.connecterUtilisateur(this, login, password); |
} |
public void connecterUtilisateur(String login, String password) { |
carnetEnLigneModele.connecterUtilisateur(new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur = uti; |
// fireEvent(CONNEXION); |
} |
/** |
* Affichage etat de la connexion |
*/ |
private void afficheEtatConnexion() { |
if (!utilisateur.isIdentifie()) { |
etatConnexionVue.setEtat(texteDeconnexion,false); |
} |
else { |
etatConnexionVue.setEtat(utilisateur.getIdentifiant()+ " (deconnexion)",true); |
} |
} |
}, login, password |
/** |
* |
* Affichage boite de connexion |
* |
*/ |
public void afficherDialogueConnexion() { |
if (formulaireDeConnexionVue==null) { |
formulaireDeConnexionVue= new FormulaireDeConnexionVue(this); |
} |
// Position it roughly in the middle of the screen. |
int left = (Window.getClientWidth() - 512) / 2; |
int top = (Window.getClientHeight() - 256) / 2; |
formulaireDeConnexionVue.setPopupPosition(left, top); |
formulaireDeConnexionVue.show(); |
} |
); |
public Panel getPanneauPrincipalCarnetEnLigne() { |
return panneauPrincipalCarnetEnLigne; |
} |
} |
// TODO : repandre rafraichissement |
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
if (nouvelleDonnees instanceof Utilisateur) { |
utilisateur = (Utilisateur) nouvelleDonnees; |
afficheEtatConnexion(); |
if ((tentativeConnection) && !utilisateur.isIdentifie()) { |
formulaireDeConnexionVue.afficherMessageAlerte(); |
} |
else { |
if ((tentativeConnection) && utilisateur.isIdentifie()) { |
formulaireDeConnexionVue.hide(); |
} |
} |
// On lance l'affichage des observations |
observationMediateur.obtenirNombreObservation(); |
} |
} |
} |
/trunk/src/org/tela_botanica/client/vues/EtatConnexionVue.java |
---|
New file |
0,0 → 1,154 |
/** |
David Delon david.delon@clapas.net 2007 |
*/ |
/* |
* EtatConnexionVue.java : affichage information portant sur le statut de la connexion utilisateur |
* |
* |
* 1: Le programme affiche le statut connecte si l'utilisateur s'est connecte precedemment, sinon s'affiche le statut deconnecte |
* 2: Le programme arme les actions liees a la connection ou a la deconnection |
* - Connection : affichage de la boite de connexion |
* - Deconnexion : appel du service de deconnexion, et appel de la re-initialisation de l'affichage pour le nouvel identifiant utilisateur obtenu (identifiant de session) |
*/ |
package org.tela_botanica.client.vues; |
import org.tela_botanica.client.CarnetEnLigneMediateur; |
import com.google.gwt.user.client.ui.ClickListener; |
import com.google.gwt.user.client.ui.HTML; |
import com.google.gwt.user.client.ui.Widget; |
import com.gwtext.client.widgets.Panel; |
/** |
* Un indicateur d'etat de connexion |
* |
* @author David Delon |
* |
*/ |
public class EtatConnexionVue extends Panel { |
/** |
* Médiateur associé à la vue |
*/ |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
/** |
* Texte lié à la connexion. |
* |
*/ |
private HTML labelEtatConnexion = null; |
/** |
* Booleen indiquant si utilisateur connecte |
* |
*/ |
private boolean connecte = false ; |
public EtatConnexionVue(CarnetEnLigneMediateur cm) { |
carnetEnLigneMediateur=cm; |
this.setSize(800,20) ; |
this.setBodyBorder(false) ; |
this.setBorder(false) ; |
// Pas de word wrap |
labelEtatConnexion=new HTML("",false); |
this.add(labelEtatConnexion); |
ajouterListeners(); |
} |
public void ajouterListeners() { |
labelEtatConnexion.addClickListener( |
new ClickListener() { |
public void onClick(Widget sender) { |
// Non connecte ? Lien vers dialogue de connection |
if (!connecte) { |
carnetEnLigneMediateur.afficherDialogueConnexion(); |
} |
else { |
carnetEnLigneMediateur.deconnecterUtilisateur(); |
} |
} |
} |
); |
} |
/** |
* Affichage de l'etat de connexion |
* @param text |
* @param connecte |
*/ |
public void setEtat(String text, boolean connecte) { |
labelEtatConnexion.setHTML(text); |
this.connecte=connecte; |
} |
} |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log$ |
* Revision 1.1 2008-11-13 11:27:05 ddelon |
* Reecriture gwt-ext |
* |
* Revision 1.1 2008-06-09 14:19:37 ddelon |
* Initialisation observation |
* |
* Revision 1.2 2008-04-28 13:10:44 ddelon |
* Integration MyGwt |
* |
* Revision 1.1 2008-01-02 21:26:04 ddelon |
* mise en place mygwt |
* |
* Revision 1.6 2007-12-22 14:48:53 ddelon |
* Documentation et refactorisation |
* |
* Revision 1.5 2007-09-17 19:25:34 ddelon |
* Documentation |
* |
* |
*/ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/trunk/src/org/tela_botanica/client/vues/FormulaireSaisieObservationVue.java |
---|
New file |
0,0 → 1,190 |
package org.tela_botanica.client.vues; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import com.gwtext.client.core.Position; |
import com.gwtext.client.widgets.Button; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.form.DateField; |
import com.gwtext.client.widgets.form.FormPanel; |
import com.gwtext.client.widgets.form.TextField; |
import com.gwtext.client.widgets.layout.ColumnLayout; |
import com.gwtext.client.widgets.layout.ColumnLayoutData; |
import com.gwtext.client.widgets.layout.FormLayout; |
/** |
* 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 { |
/** |
* Le médiateur associé à la vue |
*/ |
private ObservationMediateur observationMediateur = null; |
private TextField nameAssistant = null; |
private LocationAssistantVue locationAssistant = null; |
private DateField date = null; |
private TextField lieudit = null; |
private TextField station = null; |
private TextField milieu = null; |
private TextField comment = null; |
/** |
* Booleen d'instanciation |
*/ |
boolean estInstancie = false ; |
/** |
* Constructeur sans argument (privé car ne doit pas être utilisé) |
*/ |
private FormulaireSaisieObservationVue() |
{ |
super() ; |
} |
/** |
* Constructeur avec argument |
* @param im |
*/ |
public FormulaireSaisieObservationVue(ObservationMediateur obs) |
{ |
// on associe le médiateur |
observationMediateur = obs ; |
this.setHeader(true); |
this.setTitle("Saisie"); |
this.setCollapsible(true) ; |
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT); |
panneauFormulaire.setBorder(false); |
// Panneau intermediaire qui contient deux colonnes de formulaire |
Panel panneauIntermediaire = new Panel(); |
panneauIntermediaire.setLayout(new ColumnLayout()); |
panneauIntermediaire.setBorder(false); |
//create first panel and add fields to it |
Panel panneauPremierColonne = new Panel(); |
panneauPremierColonne.setLayout(new FormLayout()); |
panneauPremierColonne.setBorder(false); |
//create second panel and add fields to it |
Panel panneauSecondeColonne = new Panel(); |
panneauSecondeColonne.setLayout(new FormLayout()); |
panneauSecondeColonne.setBorder(false); |
locationAssistant = new LocationAssistantVue(obs); |
panneauPremierColonne.add(locationAssistant); |
station = new TextField("Station", "station", 275); |
station.setAllowBlank(true); |
panneauPremierColonne.add(station); |
date = new DateField("Date", "date", 100); |
date.setAllowBlank(true); |
date.setFormat("d/m/yyyy") ; |
panneauPremierColonne.add(date); |
nameAssistant = new TextField("Espèce", "espece", 275); |
nameAssistant.setAllowBlank(false); |
panneauPremierColonne.add(nameAssistant); |
comment = new TextField("Notes", "comment", 275); |
comment.setAllowBlank(true); |
panneauPremierColonne.add(comment); |
lieudit = new TextField("Lieu-dit", "lieudit", 275); |
lieudit.setAllowBlank(true); |
panneauSecondeColonne.add(lieudit); |
milieu = new TextField("Milieu", "milieu", 275); |
milieu.setAllowBlank(true); |
panneauSecondeColonne.add(milieu); |
panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5)); |
panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5)); |
panneauFormulaire.add(panneauIntermediaire); |
Button boutonOK = new Button("Ok"); |
panneauFormulaire.addButton(boutonOK); |
Button boutonAnnuler = new Button("Annuler"); |
panneauFormulaire.addButton(boutonAnnuler); |
this.add(panneauFormulaire) ; |
this.setAutoHeight(true); |
// on ajoute les listeners |
ajouterListeners() ; |
} |
private void ajouterListeners() |
{ |
// on ajoute un écouteur |
/*validerInfo.addListener(new ButtonListenerAdapter() { |
// gestion du clic |
public void onClick(Button button, EventObject e) { |
// lors du clic sur le bouton valider on met à jour les commentaires et la date |
// getIMediateur().mettreAJourInfo(commentaireGeneral.getText(), dateImage.getRawValue(), noteVue.getNote()) ; |
} |
}); |
*/ |
} |
/** |
* Desactive visuellement ce panneau |
*/ |
public void desactiverPanneau() |
{ |
this.setDisabled(true) ; |
} |
/** |
* Active visuellement ce panneau |
*/ |
public void activerPanneau() |
{ |
this.setDisabled(false) ; |
} |
} |
/trunk/src/org/tela_botanica/client/vues/BarrePaginationObservationVue.java |
---|
New file |
0,0 → 1,408 |
package org.tela_botanica.client.vues; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import com.gwtext.client.core.EventCallback; |
import com.gwtext.client.core.EventObject; |
import com.gwtext.client.core.Template; |
import com.gwtext.client.data.Record; |
import com.gwtext.client.data.SimpleStore; |
import com.gwtext.client.data.Store; |
import com.gwtext.client.widgets.Button; |
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.form.ComboBox; |
import com.gwtext.client.widgets.form.Field; |
import com.gwtext.client.widgets.form.TextField; |
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter; |
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter; |
/** |
* Barre de pagination asynchrone avec filtrage des touches et accès directs et séquentiels à une page |
* @author aurelien |
* |
*/ |
public class BarrePaginationObservationVue extends Toolbar implements Rafraichissable { |
/** |
* Le médiateur associé à la vue |
*/ |
private ObservationMediateur observationMediateur = null; |
/** |
* Bouton précédent |
*/ |
private ToolbarButton prevPage = new ToolbarButton("<<") ; |
/** |
* Bouton suivant |
*/ |
private ToolbarButton suivPage = new ToolbarButton(">>") ; |
/** |
* Numéro de la page courante (attention, commence à zéro pour des raisons pratiques) |
*/ |
private int pageCourante = 0 ; |
/** |
* Nombre de page total |
*/ |
private int pageTotale = 1 ; |
/** |
* Nombre d'élements total |
*/ |
private int nbElement = 0 ; |
/** |
* Nombre d'élément par page |
*/ |
private int taillePage = 0 ; |
/** |
* Texte statique de la toolbar 1 |
*/ |
private ToolbarTextItem page = new ToolbarTextItem("Page ") ; |
/** |
* Affichage de la page courante |
*/ |
private TextField champPage = new TextField(""+(pageCourante+1)) ; |
/** |
* Affichage de "sur pageTotale " |
*/ |
private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "+pageTotale) ; |
/** |
* Texte statique de la toolbar 2 |
*/ |
private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ") ; |
/** |
* Combobox permettant de selectionner le nombre d'élements à afficher par page |
* et donc de changer la variable taillePage |
*/ |
private ComboBox selecteurTaillePage = new ComboBox() ; |
/** |
* Texte statique de la toolbar 3 |
*/ |
private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ; |
/** |
* Affiche l'intervalle des éléments contenus dans la page |
*/ |
private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ; |
/** |
* retourne le mediateur associe à la barre |
*/ |
public ObservationMediateur getImediateur() |
{ |
return observationMediateur; |
} |
/*** |
* constructeur sans argument (privé car ne doit pas être utilisé) |
*/ |
private BarrePaginationObservationVue() |
{ |
super() ; |
} |
/** |
* constructeur avec paramètres |
* @param im le médiateur à associer à la barre |
*/ |
public BarrePaginationObservationVue(ObservationMediateur im) |
{ |
super() ; |
observationMediateur = im ; |
// on dispose un peu de texte et quelques espaces pour séparer les éléments |
addButton(prevPage) ; |
addSpacer() ; |
addItem(page) ; |
addField(champPage) ; |
addItem(surTotalPage) ; |
addSpacer() ; |
addButton(suivPage) ; |
champPage.setWidth(30) ; |
addSpacer() ; |
addItem(afficherNbElem) ; |
// le store contient les valeur possibles pour les tailles de page |
final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages()); |
store.load(); |
// le template definit ce que l'on affiche pour chaque element du store dans la combobox |
final Template tp = new Template("<div class=\"x-combo-list-item\">" |
+ "{nb_page}" |
+ "<div class=\"x-clear\"></div></div>"); |
tp.compile(); |
selecteurTaillePage.setTpl(tp) ; |
selecteurTaillePage.setStore(store) ; |
selecteurTaillePage.setWidth(40) ; |
selecteurTaillePage.setEditable(false) ; |
addField(selecteurTaillePage) ; |
selecteurTaillePage.setValue("20") ; |
selecteurTaillePage.setWidth(50) ; |
addItem(nbElemParPage) ; |
// on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre |
addFill() ; |
addItem(intervalleElements) ; |
addSpacer() ; |
// on ajoute les différents listeners |
ajouterListeners() ; |
} |
/** |
* ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination |
*/ |
private void ajouterListeners() |
{ |
// boutons suivants et précédents |
prevPage.addListener(new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
// si la page courante n'est pas la première |
if(pageCourante > 0) |
{ |
// on décrémente la page courante de 1 |
pageCourante -- ; |
// on rafraichit l'affichage |
rafraichirNumeroPage() ; |
// et on notifie le médiateur de l'évenement |
observationMediateur.changerNumeroPage(pageCourante) ; |
} |
} |
}) ; |
suivPage.addListener(new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
// si la page courante n'est pas la dernière |
if(pageCourante < pageTotale -1) |
{ |
// on incrémente la page courante de 1 |
pageCourante ++ ; |
// on rafraichit l'affichage |
rafraichirNumeroPage() ; |
// et on notifie le médiateur de l'évenement |
observationMediateur.changerNumeroPage(pageCourante) ; |
} |
} |
}) ; |
champPage.addListener(new TextFieldListenerAdapter() { |
public void onSpecialKey(Field field, EventObject e) { |
// on teste si la touche entrée a été pressée |
if(e.getKey() == EventObject.ENTER) |
{ |
int nouvellePage = pageCourante ; |
// on teste avec parseInt si la valeur entrée est un entier |
try |
{ |
nouvellePage = Integer.parseInt(champPage.getRawValue()) ; |
} |
// si ce n'est pas le cas alors on remet le numéro de page correct |
catch(NumberFormatException nfe) |
{ |
rafraichirNumeroPage() ; |
champPage.focus(true) ; |
return ; |
} |
// si la conversion reussit on verifie s'il est nécessaire de changer de page |
// et si la nouvelle est comprise dans l'intervalle des pages existantes (0..pageTotale) |
if(nouvellePage != pageCourante + 1 && nouvellePage > 0 && nouvellePage <= pageTotale) |
{ |
// le cas échéant, on charge la nouvelle page et on notifie le médiateur |
changerPageCourante(nouvellePage - 1) ; |
observationMediateur.changerNumeroPage(pageCourante); |
} |
else |
{ |
// sinon on reaffiche l'ancien numero de page sans rien changer |
rafraichirNumeroPage() ; |
champPage.focus(true) ; |
} |
} |
} |
public void onFocus(Field field) { |
champPage.focus(true) ; |
} |
}); |
// pour éviter de se compliquer la vie, on filtre tous les charactères non numériques |
champPage.addKeyPressListener(new EventCallback() { |
public void execute(EventObject e) { |
// si c'est un numerique |
if(Character.isDigit((char)e.getCharCode())) |
{ |
// on laisse passer |
return ; |
} |
// si c'est la touche entrée ou backspace (valider ou effacer) |
if(e.getKey() == EventObject.ENTER || e.getKey() == EventObject.BACKSPACE) |
{ |
// on laisse passer |
return ; |
} |
else |
{ |
// sinon on remet le numero de page correct et on annule l'évenement |
rafraichirNumeroPage() ; |
e.stopEvent() ; |
} |
} |
}) ; |
// listener pour la selection dans la combobox |
selecteurTaillePage.addListener(new ComboBoxListenerAdapter() { |
public void onSelect(ComboBox comboBox, Record record, int index) { |
String nouvelleTaillePageString = comboBox.getStore().getRecordAt(index).getAsString("nb_page") ; |
int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString) ; |
// si la taille de page est différente de l'ancienne |
if(nouvelleTaillePage != taillePage) |
{ |
// on la change |
changerTaillePage(nouvelleTaillePage) ; |
} |
// et on met la valeur à jour dans la combobox |
comboBox.setValue(nouvelleTaillePageString) ; |
} |
}) ; |
} |
/** |
* Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments |
* à partir des variables de classes |
*/ |
public void rafraichirNumeroPage() |
{ |
surTotalPage.setText(" sur "+pageTotale) ; |
if(nbElement == 0) |
{ |
champPage.setValue(""+(0)) ; |
// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments |
intervalleElements.setText("Observations 0 - 0 sur 0") ; |
} |
else |
{ |
champPage.setValue(""+(pageCourante+1)) ; |
// si la page n'est pas la dernière |
if(pageCourante + 1 != pageTotale) |
{ |
// sauf pour la dernière page qui contient souvent moins d'élements que le nombre d'élements par page |
intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+(pageCourante+1)*taillePage+" sur "+nbElement) ; |
} |
else |
{ |
// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments |
intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+nbElement+" sur "+nbElement) ; |
} |
} |
} |
/** |
* Met à jour la page en cours |
* @param nouvellePageCourante la nouvelle page en cours |
*/ |
public void changerPageCourante(int nouvellePageCourante) |
{ |
pageCourante = nouvellePageCourante ; |
} |
/** |
* Methode héritée de l'interface rafraichissable |
*/ |
public void rafraichir(Object nouvelleDonnees, |
boolean repandreRaffraichissement) { |
// si on reçoit un tableau de int |
if(nouvelleDonnees instanceof int[]) |
{ |
int [] page = (int[])nouvelleDonnees ; |
// le premier élement est le nombre de pages totales |
pageTotale = page[0] ; |
// le second la page en cours |
pageCourante = page[1] ; |
// le troisième la taille de la page |
taillePage = page[2] ; |
// et le dernier le nombre total d'éléments |
nbElement = page[3] ; |
// si la page courante dépasse la page totale (cas normalement improbable car géré en amont) |
// on met le numéro de page à la page courante -1 (car la page courante est comptée à partir |
// de zéro) |
if(pageCourante >= pageTotale && pageCourante != 0) |
{ |
pageCourante = pageTotale - 1 ; |
// le cas échéant on en notifie le médiateur |
observationMediateur.changerNumeroPage(pageCourante) ; |
} |
} |
// enfin on rafraichit les informations affichées à partir des nouvelles variables de classes mises à jour |
rafraichirNumeroPage() ; |
} |
/** |
* Renvoie les différents intervalles de pages possibles |
* @return un tableau de tableau de string qui contient les différentes taille de pages |
*/ |
public String[][] getNbPages() |
{ |
String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ; |
return pages ; |
} |
/** |
* Envoie au médiateur une demande pour modifier la taille de la page |
* (qui va à son tour faire les modifications nécessaires) |
* @param nouvelleTaillePage la nouvelle taille de page (élement appartenant au tableau renvoyé par getNbPages()) |
*/ |
public void changerTaillePage(int nouvelleTaillePage) { |
observationMediateur.changerTaillePage(nouvelleTaillePage) ; |
} |
/** |
* Selectionne la valeur correspond à celle passée en paramètre dans la combobox (si elle existe) |
* @param nouvelleTaillePage la nouvelle taille de page |
*/ |
public void selectionnerTaillePage(int nouvelleTaillePage) { |
selecteurTaillePage.setValue(""+nouvelleTaillePage) ; |
} |
} |
/trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java |
---|
New file |
0,0 → 1,335 |
package org.tela_botanica.client.vues; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.interfaces.VueListable; |
import org.tela_botanica.client.vues.BarrePaginationObservationVue; |
import com.gwtext.client.core.Ext; |
import com.gwtext.client.core.ExtElement; |
import com.gwtext.client.data.FieldDef; |
import com.gwtext.client.data.Record; |
import com.gwtext.client.data.RecordDef; |
import com.gwtext.client.data.Store; |
import com.gwtext.client.data.StringFieldDef; |
import com.gwtext.client.widgets.Component; |
import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
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.RowSelectionModel; |
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter; |
/** |
* 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 { |
/** |
* Le médiateur associé à la vue |
*/ |
private ObservationMediateur observationMediateur = null; |
/** |
* Config de colonne |
*/ |
private ColumnConfig etatObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig nomSaisiObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig nomRetenuObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig lieuObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig dateObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig ordreObservation; |
/** |
* Modele de colonnes |
*/ |
private ColumnModel modeleColonnes; |
/** |
* Store qui contient les données à afficher |
*/ |
private Store st = null; |
/** |
* Barre de pagination |
*/ |
private BarrePaginationObservationVue bt = null ; |
/** |
* Constructeur sans arguments (privé car ne doit pas être utilisé) |
*/ |
private ListeObservationVue() |
{ |
super() ; |
} |
/** |
* Constructeur avec argument |
* @param im le médiateur à associer |
*/ |
public ListeObservationVue(ObservationMediateur obs) { |
this.observationMediateur = obs; |
setHeader(true); |
setTitle("Observations"); |
// on place la barre de pagination |
bt = new BarrePaginationObservationVue(observationMediateur); |
this.setBottomToolbar(bt) ; |
// 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) |
etatObservation = new ColumnConfig("Transmis", "etat_observation", 50); |
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200); |
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200); |
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200); |
dateObservation = new ColumnConfig("Date", "date_observation", 70); |
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50); |
// on associe le modèle de colonnes |
ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation}; |
modeleColonnes = new ColumnModel(cm); |
this.setColumnModel(modeleColonnes); |
this.setAutoScroll(true); |
this.setAutoWidth(true); |
this.setEnableColumnResize(true); |
// FIXME: ca ne devrait pas ête obligatoire de fixer la taille |
this.setSize(800,400); |
// creation du store |
FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
FieldDef defDateObservation = new StringFieldDef("date_observation"); |
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
defLieuObservation, defDateObservation, defOrdreObservation }; |
RecordDef rd = new RecordDef(defTab); |
st = new Store(rd); |
// on associe le store |
this.setStore(st); |
this.getView().setAutoFill(true); |
// on crée un masque de chargement qui s'affichera lors des mises à jour |
this.setLoadMask("Chargement"); |
// on ajoute les listeners |
ajouterListeners(); |
} |
/** |
* Ajoute les listeners pour la gestion des évènements |
*/ |
private void ajouterListeners() { |
this.addListener(new ContainerListenerAdapter() { |
public void onHide(Component component) { |
} |
public void onRender(Component component) { |
} |
public void onShow(Component component) { |
} |
}); |
/* |
this.addGridRowListener(new GridRowListener() { |
// gestion du clic sur une ligne |
public void onRowClick(GridPanel grid, int rowIndex, EventObject e) { |
// on notifie le médiateur et on lui passe le nuémro de ligne |
getobservationMediateur().clicListeImage(rowIndex); |
} |
// gestion du clic droit |
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 |
getobservationMediateur().montrerContextMenu(e); |
} |
// gestion du double clic |
public void onRowDblClick(GridPanel grid, int rowIndex, |
EventObject e) { |
// on notifie le médiateur en lui passant le numéro de ligne |
getobservationMediateur().doubleClicListeImage(rowIndex); |
} |
}); |
*/ |
this.getSelectionModel().addListener(new RowSelectionListenerAdapter() { |
// gestion de la sélection |
public void onSelectionChange(RowSelectionModel sm) { |
// si on a rien de sélectionné |
if (sm.getCount() <= 0) { |
// on notifie le médiateur (qui désactive notamment l'accès à certaines infos) |
// getobservationMediateur().aucuneSelection(); |
} else { |
// sinon on notifie le médiateur |
// getobservationMediateur().selection(); |
// et on lui demande de synchroniser la selection avec les autres vues |
// getobservationMediateur().synchroniserSelection("liste"); |
} |
} |
}); |
} |
/** |
* Méthode héritée de l'interface VueListable |
* Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
*/ |
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; |
} |
/** |
* Méthode héritée de l'interface rafraichissable |
* @param nouvelleDonnees les nouvelles données |
* @param repandreRafraichissement le booleen de notification du rafraichissement |
*/ |
public void rafraichir(Object nouvelleDonnees, |
boolean repandreRafraichissement) { |
// si on reçoit un store |
if (nouvelleDonnees instanceof Store) { |
// on affecte celui-ci comme gestionnaire de données |
st = (Store) nouvelleDonnees; |
st.load(); |
// et on reconfigure et rafraichit la vue |
this.reconfigure(st, this.getColumnModel()); |
demasquerChargement(); |
} |
} |
/** |
* 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 BarrePaginationObservationVue getToolBarVue() |
{ |
return bt ; |
} |
/** |
* Recherche l'élement actuellement affiché et affiche son message de chargement |
*/ |
public void masquerChargement() |
{ |
ExtElement masked = Ext.get(getId()) ; |
// FIXME: parfois null sans raison ! |
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()) ; |
// FIXME: parfois null sans raison ! |
if (masked!=null) { |
if(masked.isMasked()) |
{ |
masked.unmask() ; |
} |
} |
} |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/trunk/src/org/tela_botanica/client/vues/AutoCompleteAsyncTextBox.java |
---|
New file |
0,0 → 1,360 |
/* |
Auto-Completion Textbox for GWT |
Copyright (C) 2006 Oliver Albers http://gwt.components.googlepages.com/ |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Lesser General Public License for more details. |
You should have received a copy of the GNU Lesser General Public |
License along with this library; if not, write to the Free Software |
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
*/ |
package org.tela_botanica.client.vues; |
// TODO : traiter latence (augmenter en fonction rapidit� saisie + texte vide) |
// TODO : traitement espace apres l'espece (%20) |
// TODO : Utiliser Suggestbox et les Associating Data Transfer Objects (DTOs) with Suggestion Objects |
import com.google.gwt.user.client.ui.KeyboardListener; |
import com.google.gwt.user.client.ui.ListBox; |
import com.google.gwt.user.client.ui.PopupPanel; |
import com.google.gwt.user.client.ui.TextBox; |
import com.google.gwt.user.client.ui.Widget; |
import com.google.gwt.user.client.DOM; |
import com.google.gwt.user.client.Event; |
import java.util.Vector; |
import java.util.HashMap; |
import org.tela_botanica.client.interfaces.FournisseurListe; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
public class AutoCompleteAsyncTextBox extends TextBox implements KeyboardListener { |
// Fournisseur de donnees |
private FournisseurListe fournisseurDeDonnees=null; |
private HashMap cache = new HashMap(); |
private boolean searching = false; |
private Rafraichissable rafraichissable=null; |
protected PopupPanel choicesPopup = new PopupPanel(true); |
protected ListBox choices = new ListBox() { |
public void onBrowserEvent(Event event) { |
if (Event.ONCLICK == DOM.eventGetType(event)) { |
complete(); |
} |
} |
}; |
protected Vector items = new Vector(); |
protected boolean visible = false; |
/** |
* Value linked to current text |
*/ |
protected String currentValue = null; |
/** |
* Default Constructor |
* |
*/ |
public AutoCompleteAsyncTextBox(Rafraichissable r) |
{ |
super(); |
rafraichissable=r; |
this.addKeyboardListener(this); |
choices.sinkEvents(Event.ONCLICK); |
this.setStyleName("AutoCompleteAsyncTextBox"); |
choicesPopup.add(choices); |
choicesPopup.addStyleName("AutoCompleteChoices"); |
choices.setStyleName("list"); |
} |
public void setFournisseurDeDonnees(FournisseurListe fournisseurDeDonnees) { |
this.fournisseurDeDonnees=fournisseurDeDonnees; |
} |
private void doFetchData(String match) { |
String rematch=match.replaceAll(" ","/"); |
rematch=rematch.replaceAll("%",""); |
if (this.fournisseurDeDonnees!=null && searching==false) { |
searching=true; |
fournisseurDeDonnees.obtenirListeDonnees(rafraichissable, rematch); |
} |
} |
public void onKeyDown(Widget arg0, char arg1, int arg2) { |
if(arg1 == KEY_ENTER) |
{ |
enterKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_DOWN) |
{ |
downKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_UP) |
{ |
upKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_ESCAPE) |
{ |
escapeKey(arg0, arg1, arg2); |
} |
} |
/** |
* Not used at all (probleme avec ie, qui ne comprend pas les touches meta) |
*/ |
public void onKeyPress(Widget arg0, char arg1, int arg2) { |
} |
// The down key was pressed. |
protected void downKey(Widget arg0, char arg1, int arg2) { |
int selectedIndex = choices.getSelectedIndex(); |
selectedIndex++; |
if (selectedIndex >= choices.getItemCount()) |
{ |
selectedIndex = 0; |
} |
choices.setSelectedIndex(selectedIndex); |
} |
// The up key was pressed. |
protected void upKey(Widget arg0, char arg1, int arg2) { |
int selectedIndex = choices.getSelectedIndex(); |
selectedIndex--; |
if(selectedIndex < 0) |
{ |
selectedIndex = choices.getItemCount() - 1; |
} |
choices.setSelectedIndex(selectedIndex); |
} |
// The enter key was pressed. |
protected void enterKey(Widget arg0, char arg1, int arg2) { |
if(visible) |
{ |
complete(); |
} |
else { |
// Validation de l'entree : appel asynchrone |
/* if (autoCompleteAsyncTextBoxListeners!= null) { |
autoCompleteAsyncTextBoxListeners.fireTextBoxEnter(this,this.getText(),currentValue); |
}*/ |
currentValue=null; |
this.setText(""); |
this.setValue(null); |
} |
} |
//The escape key was pressed. |
protected void escapeKey(Widget arg0, char arg1, int arg2) { |
choices.clear(); |
items.clear(); |
choicesPopup.hide(); |
visible = false; |
} |
// Any other non-special key was pressed. |
protected void otherKey(Widget arg0, char arg1, int arg2) { |
// Lancement appel |
String text = this.getText(); |
if(text.length() > 0) |
{ |
currentValue=null; |
items.clear(); |
if (getFromCache(text)!=null) { |
items=getFromCache(text); |
displayList(); |
} |
else { |
this.doFetchData(text); |
} |
} |
} |
public void onKeyUp(Widget arg0, char arg1, int arg2) { |
switch(arg1) { |
case KEY_ALT: |
case KEY_CTRL: |
case KEY_DOWN: |
case KEY_END: |
case KEY_ENTER: |
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; |
default: |
otherKey(arg0, arg1, arg2); |
break; |
} |
} |
// Display assistant |
public void displayList() { |
searching=false; |
if(this.items.size() > 0) |
{ |
addToCache(this.getText(),(Vector) items.clone()); |
choices.clear(); |
for(int i = 0; i < items.size(); i++) |
{ |
choices.addItem(((String [])items.get(i))[0],((String [])items.get(i))[1]); |
} |
// if there is only one match and it is what is in the |
// text field anyways there is no need to show autocompletion |
// if(items.size() == 1 && (((String []) items.get(0))[0]).compareTo(this.getText()) == 0) |
// { |
// choicesPopup.hide(); |
// } else { |
choices.setSelectedIndex(0); |
choices.setVisibleItemCount(items.size()); |
visible = true; |
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight()); |
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight()); |
choicesPopup.setWidth(this.getOffsetWidth() + "px"); |
choices.setWidth(this.getOffsetWidth() + "px"); |
choicesPopup.show(); |
// } |
} else { |
visible = false; |
choicesPopup.hide(); |
} |
} |
/** |
* A mouseclick in the list of items |
*/ |
public void onChange(Widget arg0) { |
complete(); |
} |
public void onClick(Widget arg0) { |
complete(); |
} |
// add selected item to textbox |
protected void complete() |
{ |
if(choices.getItemCount() > 0) |
{ |
this.setText(choices.getItemText(choices.getSelectedIndex())); |
currentValue=choices.getValue(choices.getSelectedIndex()); |
/* if (autoCompleteAsyncTextBoxListeners!= null) { |
autoCompleteAsyncTextBoxListeners.fireTextBoxComplete(responseTextHandler,this.getText(),currentValue); |
}*/ |
} |
visible=false; |
items.clear(); |
choices.clear(); |
choicesPopup.hide(); |
} |
public void addItem(String item, String value) { |
items.add(new String [] {item, value}); |
} |
private void addToCache (String query, Vector result) |
{ |
cache.put(query.toLowerCase(),result); |
} |
private Vector getFromCache (String query) |
{ |
return (Vector) cache.get(query.toLowerCase()); |
} |
public String getValue() { |
return currentValue; |
} |
public void setValue(String value) { |
this.currentValue=value; |
} |
} |
/trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java |
---|
New file |
0,0 → 1,239 |
/** |
David Delon david.delon@clapas.net 2007 |
*/ |
/* |
* LoginDialog.java (DialogBox) |
* |
* Cas d'utilisation : |
* Dialogue de validation de l'identification utilisateur |
* |
* 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe |
* 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies |
* 3 : Le dialogue transmet au systeme local les informations d'identification |
* 3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4. |
* 4 : Cloture du dialogue |
* 5 : Appel du dialogue d'importation |
*/ |
package org.tela_botanica.client.vues; |
// TODO : controle de forme sur saisie (regex integree) ... |
import org.tela_botanica.client.CarnetEnLigneMediateur; |
import com.google.gwt.user.client.ui.DialogBox; |
import com.google.gwt.user.client.ui.KeyboardListener; |
import com.gwtext.client.core.EventObject; |
import com.gwtext.client.core.Position; |
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.FormPanel; |
import com.gwtext.client.widgets.form.TextField; |
public class FormulaireDeConnexionVue extends DialogBox { |
/** |
* Médiateur associé à la vue |
*/ |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
/** |
* email saisi |
*/ |
private TextField email=null; |
/** |
* mot de passe saisi |
*/ |
private TextField motDePasse=null; |
public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) { |
carnetEnLigneMediateur=cm; |
Panel panneauPrincipalDialogue=new Panel(); |
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT); |
panneauFormulaire.setTitle("Connexion"); |
panneauFormulaire.setWidth(350); |
panneauFormulaire.setLabelWidth(100); |
/* |
* E-Mail : Zone_saisie_email |
* Mot-de-passe : Zone_saisie_mot_de_passe |
* Message d'information |
* Bouton_Ok Bouton_Annuler |
*/ |
/** |
* On ajoute les differents elements du formulaire |
*/ |
email = new TextField("E-mail", "email", 200); |
email.setAllowBlank(false); |
panneauFormulaire.add(email); |
// Mot de passe |
motDePasse = new TextField("Mot de passe", "motDePasse", 200); |
motDePasse.setAllowBlank(false); |
motDePasse.setPassword(true); |
panneauFormulaire.add(motDePasse); |
Button boutonOK = new Button("Ok"); |
panneauFormulaire.addButton(boutonOK); |
Button boutonAnnuler = new Button("Annuler"); |
panneauFormulaire.addButton(boutonAnnuler); |
// Click sur bouton de validation |
boutonOK.addListener( |
new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
} |
); |
// Click sur bouton d'annulation |
boutonAnnuler.addListener( |
new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
hide(); |
} |
} |
); |
/** |
* Validation directe depuis un champ de saisie |
* |
*/ |
// gestion de la touche entrée |
email.addKeyListener(EventObject.ENTER, new KeyListener() { |
public void onKey(int key, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
}); |
// Mot de passe |
motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() { |
public void onKey(int key, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
}); |
panneauPrincipalDialogue.add(panneauFormulaire); |
setWidget(panneauPrincipalDialogue); |
} |
/* |
* On sort sur touche echappement |
*/ |
public boolean onKeyDownPreview(char key, int modifiers) { |
switch (key) { |
case KeyboardListener.KEY_ESCAPE: |
hide(); |
break; |
} |
return true; |
} |
public void afficherMessageAlerte() { |
// |
} |
} |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log$ |
* Revision 1.1 2008-11-13 11:27:05 ddelon |
* Reecriture gwt-ext |
* |
* Revision 1.1 2008-06-09 14:19:37 ddelon |
* Initialisation observation |
* |
* Revision 1.10 2007-09-17 19:25:34 ddelon |
* Documentation |
* |
* Revision 1.9 2007-05-21 21:03:44 ddelon |
* nettoyage de code |
* |
* Revision 1.8 2007-05-21 18:14:06 ddelon |
* Gestion importation releve locaux |
* |
* Revision 1.7 2007-05-21 11:47:30 ddelon |
* meta cvs |
* |
* Revision 1.6 2007-05-21 11:39:48 ddelon |
* meta cvs |
* |
* Revision 1.5 2007-05-21 11:39:12 ddelon |
* meta cvs |
* |
* Revision 1.4 2007-05-21 11:37:35 ddelon |
* meta cvs |
* |
* Revision 1.3 2007-05-21 11:36:51 ddelon |
* meta cvs |
* |
*/ |
/trunk/src/org/tela_botanica/client/vues/LocationAssistantVue.java |
---|
New file |
0,0 → 1,107 |
package org.tela_botanica.client.vues; |
import java.util.Iterator; |
import com.google.gwt.user.client.ui.AbsolutePanel; |
import com.google.gwt.user.client.ui.Composite; |
import com.google.gwt.user.client.ui.HorizontalPanel; |
import com.gwtext.client.widgets.form.TextField; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.modeles.ListeReferentielCommune; |
import org.tela_botanica.client.modeles.ReferentielCommune; |
import org.tela_botanica.client.observation.ObservationMediateur; |
/** |
* Affiche une liste de localite qui peuvent etre selectionnees, retourne la valeur de la localite selectionne et une code associe |
* (gettext et getvalue pour le code associe) |
* Utilise un assistant de saisie asynchrone. |
*/ |
public class LocationAssistantVue extends Composite implements Rafraichissable { |
private AutoCompleteAsyncTextBox autoCompletebox = null; |
//private HorizontalPanel panel = new HorizontalPanel(); |
private AbsolutePanel panel = new AbsolutePanel(); |
private TextField textfield = new TextField("Commune","commune",275); |
private ObservationMediateur observationMediateur = null; |
public LocationAssistantVue(ObservationMediateur obs) { |
observationMediateur=obs; |
autoCompletebox = new AutoCompleteAsyncTextBox(this); |
// autoCompletebox.setFocus(true); FIXME : ne fonctionne pas |
autoCompletebox.setFournisseurDeDonnees(observationMediateur.obtenirFournisseurReferentielCommune()); |
panel.add(textfield); |
panel.add(autoCompletebox,0,0); |
//autoCompletebox.setWidth("100%"); |
initWidget(panel); |
} |
public String getText() { |
return autoCompletebox.getText(); |
} |
public void setText(String str) { |
autoCompletebox.setText(str); |
} |
public void setValue(String value) { |
autoCompletebox.setValue(value); |
} |
public String getValue() { |
return autoCompletebox.getValue(); |
} |
public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
// si l'on a reçu une liste d'observation |
if(nouvelleDonnees instanceof ListeReferentielCommune) { |
ListeReferentielCommune data = (ListeReferentielCommune) nouvelleDonnees ; |
// on la parse et on récupère les informations quiç nous interessent |
for (Iterator it = data.keySet().iterator(); it.hasNext();) |
{ |
ReferentielCommune com=(ReferentielCommune) data.get(it.next()); |
autoCompletebox.addItem(com.getCommune(),com.getDepartement()); |
} |
autoCompletebox.displayList(); |
} |
} |
} |
/trunk/src/org/tela_botanica/client/interfaces/FournisseurListe.java |
---|
New file |
0,0 → 1,21 |
package org.tela_botanica.client.interfaces; |
/** |
* Toutes les classes qui recoivent des données de manières asynchrones ou imprévisible |
* implémentent cette interface. |
* Elle permet de faire transiter le rafraichissable jusqu'au DAO et d'appeler sa méthode rafraichir un fois |
* les données reçues, tout celà en préservant bien la séparation des rôles car les classes qui font transiter |
* le rafraichissable ne connaissent que cette interface et pas le restye de l'objet |
* @author aurelien |
* |
*/ |
public interface FournisseurListe { |
/** |
* Méthode de mise à jour d'un objet |
* @param nouvelleDonnees Un objet de n'importe quel type (programmation générique) qui contient les données de mise à jour |
* @param repandreRaffraichissement indique si l'élement doit notifier d'autres éléments de sa mise à jour |
*/ |
public void obtenirListeDonnees(final Rafraichissable r, String critere); |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/trunk/src/org/tela_botanica/client/interfaces/iRetourObservation.java |
---|
4,5 → 4,5 |
public interface iRetourObservation { |
public void onRetour(Observation observation); |
public void onRetour(Observation observation); |
} |