/trunk/src/org/tela_botanica/client/CarnetEnLigne.java |
---|
File deleted |
/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,256 → 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 ; |
// Evenenements |
final static public int NOMBRE_OBSERVATION=1; |
/** Mediateur general de l'application carnet en ligne |
* |
* |
*/ |
final static public int LISTE_OBSERVATION=2; |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
private CarnetEnLigneMediateur carnetEnLigneMediateur=null; // Mediateur General |
private final ObservationModele observationModele=new ObservationModele(); |
/** |
* modele de données |
*/ |
private ObservationModele observationModele = null ; |
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"; |
/** |
* panneau principal des Observation (onglet "observation") |
*/ |
private final Panel panneauPrincipalObservation = new Panel("Observation"); |
// Composants graphiques |
/** |
* panneau a onglet pour la liste |
*/ |
private TabPanel ongletsObservation = null ; |
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 |
/** |
* conteneur du panneau a onglets |
*/ |
private Panel panneauMenuEtOngletsObservation = null ; |
// |
/** |
* liste détaillée des Observations |
*/ |
private ListeObservationVue listeObservation = null ; |
/** |
* Saisie des Observations |
*/ |
public ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur) { |
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 ; |
this.carnetEnLigneMediateur=carnetEnLigneMediateur; |
etatConnexionVue=new EtatConnexionVue(this); |
listeObservationsVue=new ListeObservationsVue(this); |
VerticalPanel panel=new VerticalPanel(); |
/** |
* |
* 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 ; |
panel.add(etatConnexionVue); |
panel.add(listeObservationsVue); |
/** |
* Le store contenant les données à afficher, que le modèle transmet au médiateur quand il le demande |
*/ |
private Store st = null ; |
RootPanel.get().add(panel); |
onInitialisation(); |
} |
/** |
* La liste des observations affichées en cours (verifier utilité) |
*/ |
private ListeObservation cacheObservation = new ListeObservation(0) ; |
/** |
/// Methodes privees |
/** |
* |
* Initialisations |
* |
* constructeur privé (on accède a la classe par la méthode getInstance |
*/ |
private void onInitialisation() { |
private ObservationMediateur(CarnetEnLigneMediateur carnetEnLigneMediateur ) |
{ |
this.carnetEnLigneMediateur=carnetEnLigneMediateur; |
afficheEtatConnexion(); |
onFiltrageListeObservation("all","all","all"); |
} |
// Demande d'identification |
// afficherMenuId() ; |
// Filtre selection lieu |
/** |
* Action sur selection d'un lieu : affichage de la liste des taxons correspondants au filtrage |
*/ |
// on crée un modèle |
observationModele = ObservationModele.Instance(this); |
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(); |
// on gère la mise en page du panneau principal |
//panneauPrincipalObservation.setLayout(new BorderLayout()); |
// Affichage des filtres |
listeObservationsVue.displayFilter(); |
// 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); |
/// UTILISATEUR |
// Le formulaire de saisie / modification d'observation |
formulaireSaisieObservationVue = new FormulaireSaisieObservationVue(this); |
/** |
* Affichage etat de la connexion |
*/ |
//panneauListeObservation.setLayout(new FitLayout()); |
//panneauListeObservation.setSize(600,600); |
//panneauListeObservation.add(listeObservation); |
private void afficheEtatConnexion() { |
if (!carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
etatConnexionVue.setEtat(texteDeconnexion,false); |
// 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); |
} |
else { |
etatConnexionVue.setEtat(carnetEnLigneMediateur.getUtilisateur().getIdentifiant()+ " (deconnexion)",true); |
/** |
* 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 ; |
} |
} |
/** |
* |
* Affichage boite de connexion |
* |
* envoie au modèle une demande de mise a jour |
*/ |
public void afficherDialogueConnexion() { |
// TODO : singleton ? |
formulaireDeConnexionVue = new FormulaireDeConnexionVue(this); |
public void obtenirNombreObservation() { |
// 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(); |
listeObservation.masquerChargement(); |
observationModele.obtenirNombreObservation(this) ; |
} |
/** |
* Deconnexion de l'utilisateur en cours |
* envoie au modèle une demande de mise a jour |
*/ |
public void deconnecterUtilisateur() { |
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.DECONNEXION,this); |
carnetEnLigneMediateur.deconnecterUtilisateur(); |
public void obtenirListeObservation() { |
observationModele.obtenirListeObservation(this, taillePage, pageEncours) ; |
} |
/** |
* Tentative de connexion utilisateur |
* @param login |
* @param password |
* 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"} } ; |
public void connecterUtilisateur(String login, String password) { |
return valeursFiltres ; |
} |
// carnetEnLigneMediateur.addListener(CarnetEnLigneMediateur.CONNEXION,this); |
carnetEnLigneMediateur.connecterUtilisateur(login, password); |
public String getIdentifiant() { |
return carnetEnLigneMediateur.getUtilisateur().getIdentifiant(); |
} |
public Panel getPanneauPrincipalObservation() { |
return panneauPrincipalObservation; |
} |
/// OBSERVATION |
/** |
* Recherche nombre d'enregistrement pour l'utilisateur et la localite en cours |
* |
*/ |
// TODO : plutot dans la listevu non ? |
public void getNombreObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre ) { |
public void rafraichir(Object nouvelleDonnees, boolean repandreRafraichissement) { |
observationModele.getNombreObservation( |
new iRetourObservation() { |
public void onRetour(Observation obs) { |
observation=obs; |
//fireEvent(NOMBRE_OBSERVATION); |
// si l'on a reçu une liste d'observation |
if(nouvelleDonnees instanceof ListeObservation) |
{ |
ListeObservation data = (ListeObservation) nouvelleDonnees ; |
Object[][] observationData = new Object[data.size()][8]; |
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();) |
{ |
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre |
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(); |
i++ ; |
} |
public void getListeObservation (String identifiantLocalite, String localite, String annee, String mois, String jour, String lieudit, String rechercheLibre, int debut, int longueur) { |
// 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"); |
observationModele.getListeObservation( |
new iRetourObservation() { |
public void onRetour(Observation obs) { |
observation=obs; |
//fireEvent(LISTE_OBSERVATION); |
// on associe le store |
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) ; |
} |
} |
}, carnetEnLigneMediateur.getUtilisateur().getIdentifiant(), identifiantLocalite, localite , annee, mois, jour, lieudit ,rechercheLibre, debut, longueur |
); |
// 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(); |
} |
} |
/** |
* Met à jour les barre d'outils avec des nouvelles valeurs |
* @param pageMax le nombre de pages |
* @param pageEncours la page en cours |
* @param taillePage la taille de page |
* @param nbElement le nombre d'élements par page |
*/ |
public void changerPageMaxEtCourante(int pageMax, int pageEncours, int taillePage, int nbElement) |
{ |
public Observation getObservation() { |
return observation; |
int[] pages = {pageMax,pageEncours, taillePage, nbElement} ; |
listeObservation.getToolBarVue().rafraichir(pages, false) ; |
} |
/** |
* Calcule le nombre de pages nécessaires pour afficher un nombre d'élements donnés en fonction de la taille de page |
* en cours |
* @param nbElements le nombre d'élements total |
* @return le nombre de pages |
*/ |
public int calculerNbPages(int nbElements) |
{ |
// A cause de la betise de java pour les conversion implicite on fait quelques conversions manuellement |
// pour eviter qu'il arrondisse mal la division |
// nombre de pages = (nombre d'element / taille de la page) arrondie à l'entier superieur |
/// EVENEMENTS |
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() ; |
} |
/** |
* Evenements |
* |
* 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 handleEvent(BaseEvent be) { |
switch (be.type) { |
case CarnetEnLigneMediateur.DECONNEXION: |
afficheEtatConnexion(); |
break; |
case CarnetEnLigneMediateur.CONNEXION: |
if (carnetEnLigneMediateur.getUtilisateur().isIdentifie()) { |
formulaireDeConnexionVue.hide(); |
afficheEtatConnexion(); |
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()) ; |
} |
else { |
formulaireDeConnexionVue.afficherMessageAlerte(); // Erreur identification |
/** |
* 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); |
} |
break; |
} |
} |
/** |
* 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) ; |
// On lance le chargerment des observations |
obtenirNombreObservation(); |
// et on met à jour la taille de page dans les barres d'outils |
listeObservation.getToolBarVue().selectionnerTaillePage(nouvelleTaillePage); |
} |
// Retourne le fournisseur de donnee en referentiel Commune. doit posseder la methode obtenirListeDonnees() |
public FournisseurListe obtenirFournisseurReferentielCommune() { |
return observationModele.obtenirFournisseurReferentielCommune() ; |
} |
} |
/trunk/src/org/tela_botanica/client/observation/ListeObservationsVue.java |
---|
183,7 → 183,7 |
// TODO : renderer date, alignement etc |
/* |
columns[0] = new TableColumn("etat","Aransmis", 50); |
columns[0] = new TableColumn("etat","Transmis", 50); |
columns[1] = new TableColumn("nom","Nom saisi", 250); |
323,7 → 323,7 |
setStatusDisabled(); |
// observationMediateur.addListener(ObservationMediateur.NOMBRE_OBSERVATION,this); |
observationMediateur.getNombreObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre); // Retour dans handlevent() NOMBRE_OBSERVATION |
// observationMediateur.getNombreObservation(identifiantLocalite,localite,annee, mois, jour ,lieudit,rechercheLibre); // Retour dans handlevent() NOMBRE_OBSERVATION |
} |
338,14 → 338,14 |
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.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]; |
355,7 → 355,7 |
values[4]="4"; |
values[5]="5"; |
values[1]=listeObservation[i].getNomSaisi(); |
*/ |
// table.add(new TableItem(values)); |
} |
592,7 → 592,7 |
*/ |
} |
// } |
/** |
891,6 → 891,9 |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log$ |
* 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 |
* |
/trunk/src/org/tela_botanica/client/observation/ObservationModele.java |
---|
1,37 → 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; |
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; |
public class ObservationModele { |
private final String baseURL; |
/** |
* Booleen indiquant si le médiateur est instancié (l'instance doit être unique donc le booleen est static) |
*/ |
private static boolean estInstancie = false ; |
public ObservationModele() { |
baseURL=Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
/** |
* 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) { |
new ObservationAsynchroneDAO().getNombreObservation(baseURL, retour, identifiant, identifiantLocalite, localite, annee, mois, jour, lieudit, rechercheLibre ); |
private ObservationModele(ObservationMediateur observationMediateur) { |
this.observationMediateur=observationMediateur; |
config = new Configuration(); |
} |
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) { |
new ObservationAsynchroneDAO().getListeObservation(baseURL, retour, identifiant, identifiantLocalite, localite, annee, mois, jour, lieudit, rechercheLibre, debut, longueur ); |
/** |
* 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 FournisseurListe obtenirFournisseurReferentielCommune() { |
return new ListeReferentielCommuneAsynchroneDAO(this); |
} |
/** |
* 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,97 → 1,187 |
package org.tela_botanica.client; |
import org.tela_botanica.client.image.ImageMediateur; |
import org.tela_botanica.client.interfaces.iMediateur; |
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; |
import com.google.gwt.user.client.Window; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.layout.VerticalLayout; |
public class CarnetEnLigneMediateur { |
/** |
* Mediateur gérant les interactions entre vues et les echanges de données |
* C'est un singleton. |
* @author david delon |
* |
*/ |
// Evenenements |
final static public int ETAT_CONNEXION=1; |
final static public int DECONNEXION=2; |
final static public int CONNEXION = 3; |
public class CarnetEnLigneMediateur implements Rafraichissable { |
private final CarnetEnLigneModele carnetEnLigneModele; |
private Utilisateur utilisateur=null; |
/** |
* booleen qui verifie l'unicite de l'instance |
*/ |
private static boolean estInstancie = false ; |
// Fonctionnement servicecs |
private boolean async=true; |
/** |
* modele de données |
*/ |
private CarnetEnLigneModele carnetEnLigneModele=null; |
public CarnetEnLigneMediateur() { |
carnetEnLigneModele=new CarnetEnLigneModele(); |
//addListener(ETAT_CONNEXION,this); |
getEtatUtilisateur(); // Alimente Objet Utilisateur |
/** |
* panneau principal de l'application "Carnet en ligne" |
*/ |
} |
private Panel panneauPrincipalCarnetEnLigne=new Panel("Carnet en ligne"); |
/** |
* Fin construction (est appelle sur reception evenement Applicatif ETAT_CONNEXION) |
* panneau a onglet pour les observation et les images |
*/ |
private Panel ongletsObservationsImages=null; |
/** |
* Indicateur d'etat de la connexion utilisateur |
*/ |
private EtatConnexionVue etatConnexionVue=null; |
/** |
* 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; |
/** |
* Formulaire de connexion (lazy instantiation) |
* |
*/ |
private void _CarnetEnLigneMediateur() { |
private FormulaireDeConnexionVue formulaireDeConnexionVue=null; |
ImageMediateur.Instance() ; |
new ObservationMediateur(this); |
} |
/** |
* Mediateur Gestion des images |
*/ |
private void getEtatUtilisateur() { // Pourrait devenir publique ... |
private ImageMediateur imageMediateur=null; |
// TODO : utiliser une factory ici : Avec Modele synchrone ou non, ou au niveau methode comme dans cette exemple |
/** |
* Mediateur Gestion des observations |
*/ |
private ObservationMediateur observationMediateur=null; |
// Pas possible de traiter dans Modele car retour asynchrone devant etre traité ici. |
// if asynchrone |
if (async) { |
carnetEnLigneModele.getUtilisateurAsynchroneDAO( |
new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur=uti; |
// fireEvent(ETAT_CONNEXION); |
} |
/** |
* Utilisateur en cours |
*/ |
} |
private Utilisateur utilisateur=null; |
); |
public static CarnetEnLigneMediateur Instance() |
{ |
if(!estInstancie) |
{ |
estInstancie = true ; |
return new CarnetEnLigneMediateur() ; |
} |
// else if synchrone |
else { |
else |
{ |
return null ; |
} |
} |
utilisateur= carnetEnLigneModele.getUtilisateurSynchroneDAO(); |
_CarnetEnLigneMediateur(); |
} |
/** |
* constructeur privé (on accède a la classe par la méthode getInstance |
*/ |
private CarnetEnLigneMediateur() { |
// Disposition |
panneauPrincipalCarnetEnLigne.setLayout(new VerticalLayout()); |
// On crée un modèle d'acces aux donnnes |
carnetEnLigneModele=CarnetEnLigneModele.Instance(); |
// La vue affichant le statut de la connexion |
etatConnexionVue=new EtatConnexionVue(this); |
// 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(); |
// on ajoute les panneaux principaux des applications au panneau à onglets |
// ongletsObservationsImages.add(imageMediateur.getPanneauPrincipalImage()); |
ongletsObservationsImages.add(observationMediateur.getPanneauPrincipalObservation()); |
} |
// Evenenements Applicatifs |
/* |
public void handleEvent(BaseEvent be) { |
if (be.type==CarnetEnLigneMediateur.ETAT_CONNEXION) { |
_CarnetEnLigneMediateur(); // Fin initialisation |
public void getEtatUtilisateur() { |
carnetEnLigneModele.getEtatUtilisateur(this); |
} |
} |
*/ |
// Methode publiques |
/** |
* Recherche Identifiant utilisateur en cours et etat de connection |
* @return Utilisateur |
108,39 → 198,102 |
public void deconnecterUtilisateur() { |
carnetEnLigneModele.deconnecterUtilisateur( |
new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur=uti; |
//fireEvent(DECONNEXION); |
carnetEnLigneModele.deconnecterUtilisateur(this, utilisateur.getIdentifiant()); |
} |
public void connecterUtilisateur(String login, String password) { |
}, utilisateur.getIdentifiant() |
tentativeConnection=true; |
carnetEnLigneModele.connecterUtilisateur(this, login, password); |
); |
} |
/** |
* Affichage etat de la connexion |
*/ |
private void afficheEtatConnexion() { |
if (!utilisateur.isIdentifie()) { |
etatConnexionVue.setEtat(texteDeconnexion,false); |
} |
else { |
etatConnexionVue.setEtat(utilisateur.getIdentifiant()+ " (deconnexion)",true); |
} |
public void connecterUtilisateur(String login, String password) { |
} |
carnetEnLigneModele.connecterUtilisateur( |
new iRetourUtilisateur() { |
public void onRetour(Utilisateur uti) { |
utilisateur=uti; |
//fireEvent(CONNEXION); |
/** |
* |
* 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; |
}, login, password |
); |
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/image/ImageMediateur.java |
---|
205,9 → 205,7 |
panneauPrincipalImage.add(panneauMenuEtOngletsImage,regionCentre); |
// et le panneau de métadonnées et d'info sur le coté droit |
panneauPrincipalImage.add(detailsEtMotsCles,regionEst); |
} |
/** |
* Change la valeur du booleen de selection |
* @param selection la nouvelle valeur du booléen |
414,6 → 412,14 |
} |
public void afficherMenuId() |
{ |
IdVue i = new IdVue(this) ; |
i.show() ; |
} |
/** |
* Renvoie l'identifiant de la vue en cours |
* @return l'identifiant de la vue en cours de visualisation |
1042,12 → 1048,10 |
} |
public void afficherMenuId() |
{ |
IdVue i = new IdVue(this) ; |
i.show() ; |
} |
// Lancement identification |
/** |
* C'est dans cette fonction que doivent être renvoyé les valeurs des filtres |
* sous forme de tableau [nom, valeur] |
/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/vues/EtatConnexionVue.java |
---|
New file |
0,0 → 1,151 |
/** |
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-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 |
* |
* |
*/ |
/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() ; |
} |
} |
} |
} |
/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,236 |
/** |
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-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/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); |
} |
/trunk/src/org/tela_botanica/client/CarnetEnLigneModele.java |
---|
6,60 → 6,87 |
*/ |
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 CarnetEnLigneModele() { |
baseURL=Dictionary.getDictionary("Parameters").get("serviceBaseUrl"); |
public static CarnetEnLigneModele Instance() |
{ |
if(!estInstancie) |
{ |
estInstancie = true ; |
return new CarnetEnLigneModele() ; |
} |
else |
{ |
return null ; |
} |
} |
/** |
* |
* |
*/ |
public void getUtilisateurAsynchroneDAO(final iRetourUtilisateur retour) { |
new UtilisateurAsynchroneDAO().getUtilisateur(baseURL,retour ); |
private CarnetEnLigneModele() { |
config = new Configuration(); |
} |
/** |
* |
* |
*/ |
public Utilisateur getUtilisateurSynchroneDAO() { |
public void deconnecterUtilisateur(Rafraichissable r, String user) { |
return new Utilisateur("David Delon synchrone",true); |
new UtilisateurAsynchroneDAO(this).deconnecterUtilisateur(r,user ); |
} |
public void deconnecterUtilisateur(final iRetourUtilisateur retour, String user) { |
public void connecterUtilisateur(Rafraichissable r, String login , String password) { |
new UtilisateurAsynchroneDAO().deconnecterUtilisateur(baseURL,retour,user ); |
new UtilisateurAsynchroneDAO(this).connecteUtilisateur(r,login, password ); |
} |
public void getEtatUtilisateur(Rafraichissable r) { |
new UtilisateurAsynchroneDAO(this).getEtatUtilisateur(r); |
} |
public void connecterUtilisateur(final iRetourUtilisateur retour, String login , String password) { |
new UtilisateurAsynchroneDAO().connecteUtilisateur(baseURL,retour,login, password ); |
/** |
* Accesseur pour la configuration en cours d'utilisation |
* |
* @return la configuration |
*/ |
public Configuration getConfig() { |
return config; |
} |
} |
/trunk/src/org/tela_botanica/client/cel2.java |
---|
1,20 → 1,12 |
package org.tela_botanica.client; |
import org.tela_botanica.client.image.ImageMediateur; |
import com.google.gwt.core.client.EntryPoint; |
import com.google.gwt.user.client.ui.Button; |
import com.google.gwt.user.client.ui.ClickListener; |
import com.google.gwt.user.client.ui.DialogBox; |
import com.google.gwt.user.client.ui.Image; |
import com.google.gwt.user.client.ui.RootPanel; |
import com.google.gwt.user.client.ui.VerticalPanel; |
import com.google.gwt.user.client.ui.Widget; |
import com.gwtext.client.widgets.Viewport; |
/** |
* Entry point classes define <code>onModuleLoad()</code>. |
*/ |
public class cel2 implements EntryPoint { |
/** |
22,8 → 14,15 |
*/ |
public void onModuleLoad() { |
ImageMediateur im = ImageMediateur.Instance() ; |
CarnetEnLigneMediateur carnetEnLigneMediateur= CarnetEnLigneMediateur.Instance(); |
new Viewport(im.getPanneauPrincipalImage()); |
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/Configuration.java |
---|
New file |
0,0 → 1,43 |
package org.tela_botanica.client.modeles; |
import com.google.gwt.i18n.client.Dictionary; |
/** |
* Classe chargeant certains paramètres de configuration à partir d'un fichier |
* javascript (config.js) |
* |
* @author aurelien |
* |
*/ |
public class Configuration { |
/** |
* L'url de base du serveur jrest |
*/ |
private String serviceBaseUrl; |
private String imageBaseUrl; |
/** |
* Constructeur sans argument |
*/ |
public Configuration() { |
// on utilise le dictionnaire d'internationalisation pour lire les |
// variables du fichier javascript |
Dictionary theme = Dictionary.getDictionary("configuration"); |
serviceBaseUrl=theme.get("serviceBaseUrl"); |
} |
/** |
* Accesseur pour l'url de base du serveur jrest |
* |
* @return une url de la forme http://emplacement_serveur/jrest |
*/ |
public String getServiceBaseUrl() { |
return serviceBaseUrl; |
} |
} |
/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/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; |
19,15 → 20,25 |
/** |
* Le modèle associé au DAO |
*/ |
private CarnetEnLigneModele carnetEnLigneModele = null ; |
/** |
* Constructeur |
*/ |
public UtilisateurAsynchroneDAO() { |
public UtilisateurAsynchroneDAO(CarnetEnLigneModele carnetEnLigneModele) { |
this.carnetEnLigneModele=carnetEnLigneModele; |
} |
/** |
* Methode de classe d'appel du service gestion identification |
* @param baseURL : URL du service |
34,11 → 45,11 |
* @param retour : methode appelle en retour d'appel |
*/ |
public void getUtilisateur(String baseURL, final iRetourUtilisateur retour) { |
public void getEtatUtilisateur(final Rafraichissable r) { |
// 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); |
51,7 → 62,7 |
boolean identifie = ((JSONBoolean) jsonArray.get(1)) |
.booleanValue(); // Drapeau leve si utilisateur |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, identifie)); |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
60,9 → 71,9 |
public void deconnecterUtilisateur(String baseURL, final iRetourUtilisateur retour, String user) { |
public void deconnecterUtilisateur(final Rafraichissable r, String user) { |
HTTPRequest.asyncGet(baseURL + "/User/" + user , |
HTTPRequest.asyncGet(carnetEnLigneModele.getConfig().getServiceBaseUrl()+ "/User/" + user , |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
78,8 → 89,7 |
.booleanValue(); // Drapeau leve si utilisateur |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, identifie)); |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
87,9 → 97,9 |
public void connecteUtilisateur(String baseURL,final iRetourUtilisateur retour, String login, String password) { |
public void connecteUtilisateur (final Rafraichissable r, String login, String password) { |
HTTPRequest.asyncGet(baseURL + "/User/" + login + "/" + password , |
HTTPRequest.asyncGet(carnetEnLigneModele.getConfig().getServiceBaseUrl() + "/User/" + login + "/" + password , |
new ResponseTextHandler() { |
public void onCompletion(String str) { |
107,7 → 117,7 |
// deja identifie |
retour.onRetour(new Utilisateur(identifiant, identifie)); |
r.rafraichir(new Utilisateur(identifiant, identifie),true); |
} |
} |
}); |
114,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; |
} |
} |
/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/modeles/Observation.java |
---|
4,9 → 4,6 |
public class Observation { |
private int nombreObservations=0; |
private Observation [] listeObservation=null; |
private String transmis=null; |
private String nomSaisi=null; |
private String nomRetenu=null; |
28,22 → 25,6 |
/** |
* Constructeur nombre total d'observations |
* @param i |
*/ |
public Observation(int i) { |
nombreObservations=i; |
} |
public int getNombreObservations() { |
return nombreObservations; |
} |
/** |
* @param transmis |
* @param nomSaisi |
* @param nomRetenu |
77,19 → 58,70 |
} |
public Observation(Observation[] listeObservation) { |
this.listeObservation=listeObservation; |
public String getNomSaisi() { |
return nomSaisi; |
} |
public Observation[] getListeObservation() { |
return listeObservation; |
public String getNumeroOrdre() { |
return numeroOrdre; |
} |
public String getNomSaisi() { |
return nomSaisi; |
public String getCommentaire() { |
return commentaire; |
} |
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]); |
} |
} |
} |
} |