Subversion Repositories eFlore/Applications.cel

Compare Revisions

No changes between revisions

Ignore whitespace Rev 11 → Rev 12

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