Subversion Repositories eFlore/Archives.cel-v2

Compare Revisions

Ignore whitespace Rev 48 → Rev 49

/trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java
New file
0,0 → 1,335
package org.tela_botanica.client.vues;
 
 
import org.tela_botanica.client.observation.ObservationMediateur;
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.interfaces.VueListable;
import org.tela_botanica.client.vues.BarrePaginationObservationVue;
 
import com.gwtext.client.core.Ext;
import com.gwtext.client.core.ExtElement;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Component;
import com.gwtext.client.widgets.event.ContainerListenerAdapter;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.RowSelectionModel;
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter;
 
/**
* Liste d'observation composée de ligne d'observation
* l'interface rafraichissable et l'interface vueListable
*
* @author David Delon 2008
*/
public class ListeObservationVue extends GridPanel implements Rafraichissable,
VueListable {
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
 
 
/**
* Config de colonne
*/
private ColumnConfig etatObservation;
/**
* Config de colonne
*/
private ColumnConfig nomSaisiObservation;
/**
* Config de colonne
*/
private ColumnConfig nomRetenuObservation;
/**
* Config de colonne
*/
private ColumnConfig lieuObservation;
/**
* Config de colonne
*/
private ColumnConfig dateObservation;
/**
* Config de colonne
*/
private ColumnConfig ordreObservation;
/**
* Modele de colonnes
*/
private ColumnModel modeleColonnes;
 
/**
* Store qui contient les données à afficher
*/
private Store st = null;
/**
* Barre de pagination
*/
private BarrePaginationObservationVue bt = null ;
 
/**
* Constructeur sans arguments (privé car ne doit pas être utilisé)
*/
private ListeObservationVue()
{
super() ;
}
/**
* Constructeur avec argument
* @param im le médiateur à associer
*/
public ListeObservationVue(ObservationMediateur obs) {
this.observationMediateur = obs;
setHeader(true);
setTitle("Observations");
// on place la barre de pagination
bt = new BarrePaginationObservationVue(observationMediateur);
this.setBottomToolbar(bt) ;
 
// on construit le modèle de colonnes
 
// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir)
etatObservation = new ColumnConfig("Transmis", "etat_observation", 50);
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200);
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200);
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200);
dateObservation = new ColumnConfig("Date", "date_observation", 70);
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50);
// on associe le modèle de colonnes
ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation};
modeleColonnes = new ColumnModel(cm);
this.setColumnModel(modeleColonnes);
this.setAutoScroll(true);
this.setAutoWidth(true);
this.setEnableColumnResize(true);
 
// FIXME: ca ne devrait pas ête obligatoire de fixer la taille
this.setSize(800,400);
// creation du store
FieldDef defEtatObservation = new StringFieldDef("etat_observation");
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation");
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation");
FieldDef defLieuObservation = new StringFieldDef("lieu_observation");
FieldDef defDateObservation = new StringFieldDef("date_observation");
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation");
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation,
defLieuObservation, defDateObservation, defOrdreObservation };
RecordDef rd = new RecordDef(defTab);
st = new Store(rd);
// on associe le store
this.setStore(st);
this.getView().setAutoFill(true);
// on crée un masque de chargement qui s'affichera lors des mises à jour
this.setLoadMask("Chargement");
// on ajoute les listeners
ajouterListeners();
}
 
 
/**
* Ajoute les listeners pour la gestion des évènements
*/
private void ajouterListeners() {
this.addListener(new ContainerListenerAdapter() {
 
public void onHide(Component component) {
 
}
 
public void onRender(Component component) {
}
 
public void onShow(Component component) {
 
}
 
});
 
/*
this.addGridRowListener(new GridRowListener() {
// gestion du clic sur une ligne
public void onRowClick(GridPanel grid, int rowIndex, EventObject e) {
 
// on notifie le médiateur et on lui passe le nuémro de ligne
getobservationMediateur().clicListeImage(rowIndex);
}
// gestion du clic droit
public void onRowContextMenu(GridPanel grid, int rowIndex,
EventObject e) {
// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu
e.stopEvent() ;
// on notifie le médiateur en lui passant l'évenement
getobservationMediateur().montrerContextMenu(e);
}
 
// gestion du double clic
public void onRowDblClick(GridPanel grid, int rowIndex,
EventObject e) {
// on notifie le médiateur en lui passant le numéro de ligne
getobservationMediateur().doubleClicListeImage(rowIndex);
}
});
*/
this.getSelectionModel().addListener(new RowSelectionListenerAdapter() {
 
// gestion de la sélection
public void onSelectionChange(RowSelectionModel sm) {
 
// si on a rien de sélectionné
if (sm.getCount() <= 0) {
// on notifie le médiateur (qui désactive notamment l'accès à certaines infos)
// getobservationMediateur().aucuneSelection();
} else {
// sinon on notifie le médiateur
// getobservationMediateur().selection();
// et on lui demande de synchroniser la selection avec les autres vues
// getobservationMediateur().synchroniserSelection("liste");
}
}
});
}
 
/**
* Méthode héritée de l'interface VueListable
* Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres
*/
public String[] getIdSelectionnees() {
Record[] selection = this.getSelectionModel().getSelections();
int taille = selection.length;
String id_selection[] = new String[taille];
 
for (int i = 0; i < selection.length; i++) {
 
id_selection[i] = selection[i].getAsString("ordre_observation");
}
 
return id_selection;
}
/**
* Méthode héritée de l'interface rafraichissable
* @param nouvelleDonnees les nouvelles données
* @param repandreRafraichissement le booleen de notification du rafraichissement
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRafraichissement) {
 
// si on reçoit un store
if (nouvelleDonnees instanceof Store) {
// on affecte celui-ci comme gestionnaire de données
st = (Store) nouvelleDonnees;
st.load();
// et on reconfigure et rafraichit la vue
this.reconfigure(st, this.getColumnModel());
demasquerChargement();
}
 
}
 
/**
* Sélectionne des enregistrements donné
* @param sel un tableau d'enregistrement à selectionner
*/
public void selectionnerEnregistrements(Record[] sel) {
 
getSelectionModel().clearSelections();
getSelectionModel().selectRecords(sel);
}
/**
* Accesseur pour la toolbar de pagination
* @return la toolbar de pagination
*/
public BarrePaginationObservationVue getToolBarVue()
{
return bt ;
}
 
 
/**
* Recherche l'élement actuellement affiché et affiche son message de chargement
*/
public void masquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
 
// FIXME: parfois null sans raison !
if (masked!=null) {
masked.mask("Chargement") ;
}
 
}
/**
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché
*/
public void demasquerChargement()
{
ExtElement masked = Ext.get(getId()) ;
// FIXME: parfois null sans raison !
if (masked!=null) {
if(masked.isMasked())
{
masked.unmask() ;
}
}
}
 
 
 
}
/trunk/src/org/tela_botanica/client/vues/AutoCompleteAsyncTextBox.java
New file
0,0 → 1,360
/*
Auto-Completion Textbox for GWT
Copyright (C) 2006 Oliver Albers http://gwt.components.googlepages.com/
 
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
 
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
*/
 
package org.tela_botanica.client.vues;
 
 
// TODO : traiter latence (augmenter en fonction rapidit� saisie + texte vide)
// TODO : traitement espace apres l'espece (%20)
// TODO : Utiliser Suggestbox et les Associating Data Transfer Objects (DTOs) with Suggestion Objects
 
import com.google.gwt.user.client.ui.KeyboardListener;
import com.google.gwt.user.client.ui.ListBox;
import com.google.gwt.user.client.ui.PopupPanel;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
 
import java.util.Vector;
import java.util.HashMap;
 
import org.tela_botanica.client.interfaces.FournisseurListe;
import org.tela_botanica.client.interfaces.Rafraichissable;
 
 
 
public class AutoCompleteAsyncTextBox extends TextBox implements KeyboardListener {
// Fournisseur de donnees
private FournisseurListe fournisseurDeDonnees=null;
private HashMap cache = new HashMap();
private boolean searching = false;
private Rafraichissable rafraichissable=null;
protected PopupPanel choicesPopup = new PopupPanel(true);
protected ListBox choices = new ListBox() {
public void onBrowserEvent(Event event) {
if (Event.ONCLICK == DOM.eventGetType(event)) {
complete();
}
}
};
protected Vector items = new Vector();
protected boolean visible = false;
/**
* Value linked to current text
*/
protected String currentValue = null;
/**
* Default Constructor
*
*/
public AutoCompleteAsyncTextBox(Rafraichissable r)
{
super();
rafraichissable=r;
this.addKeyboardListener(this);
choices.sinkEvents(Event.ONCLICK);
this.setStyleName("AutoCompleteAsyncTextBox");
choicesPopup.add(choices);
choicesPopup.addStyleName("AutoCompleteChoices");
choices.setStyleName("list");
}
 
public void setFournisseurDeDonnees(FournisseurListe fournisseurDeDonnees) {
this.fournisseurDeDonnees=fournisseurDeDonnees;
}
private void doFetchData(String match) {
 
String rematch=match.replaceAll(" ","/");
rematch=rematch.replaceAll("%","");
if (this.fournisseurDeDonnees!=null && searching==false) {
searching=true;
fournisseurDeDonnees.obtenirListeDonnees(rafraichissable, rematch);
 
}
}
 
public void onKeyDown(Widget arg0, char arg1, int arg2) {
if(arg1 == KEY_ENTER)
{
enterKey(arg0, arg1, arg2);
}
else if(arg1 == KEY_DOWN)
{
downKey(arg0, arg1, arg2);
}
else if(arg1 == KEY_UP)
{
upKey(arg0, arg1, arg2);
}
else if(arg1 == KEY_ESCAPE)
{
escapeKey(arg0, arg1, arg2);
}
}
/**
* Not used at all (probleme avec ie, qui ne comprend pas les touches meta)
*/
public void onKeyPress(Widget arg0, char arg1, int arg2) {
 
}
// The down key was pressed.
protected void downKey(Widget arg0, char arg1, int arg2) {
int selectedIndex = choices.getSelectedIndex();
selectedIndex++;
if (selectedIndex >= choices.getItemCount())
{
selectedIndex = 0;
}
choices.setSelectedIndex(selectedIndex);
}
 
// The up key was pressed.
protected void upKey(Widget arg0, char arg1, int arg2) {
int selectedIndex = choices.getSelectedIndex();
selectedIndex--;
if(selectedIndex < 0)
{
selectedIndex = choices.getItemCount() - 1;
}
choices.setSelectedIndex(selectedIndex);
}
 
// The enter key was pressed.
protected void enterKey(Widget arg0, char arg1, int arg2) {
if(visible)
{
complete();
}
else {
// Validation de l'entree : appel asynchrone
/* if (autoCompleteAsyncTextBoxListeners!= null) {
autoCompleteAsyncTextBoxListeners.fireTextBoxEnter(this,this.getText(),currentValue);
}*/
currentValue=null;
this.setText("");
this.setValue(null);
}
 
}
 
//The escape key was pressed.
protected void escapeKey(Widget arg0, char arg1, int arg2) {
choices.clear();
items.clear();
choicesPopup.hide();
visible = false;
 
}
 
 
// Any other non-special key was pressed.
protected void otherKey(Widget arg0, char arg1, int arg2) {
// Lancement appel
String text = this.getText();
if(text.length() > 0)
{
currentValue=null;
 
items.clear();
if (getFromCache(text)!=null) {
items=getFromCache(text);
displayList();
}
else {
this.doFetchData(text);
}
}
}
public void onKeyUp(Widget arg0, char arg1, int arg2) {
switch(arg1) {
case KEY_ALT:
case KEY_CTRL:
case KEY_DOWN:
case KEY_END:
case KEY_ENTER:
case KEY_ESCAPE:
case KEY_HOME:
case KEY_LEFT:
case KEY_PAGEDOWN:
case KEY_PAGEUP:
case KEY_RIGHT:
case KEY_SHIFT:
case KEY_TAB:
case KEY_UP:
break;
default:
otherKey(arg0, arg1, arg2);
break;
}
 
}
// Display assistant
public void displayList() {
searching=false;
if(this.items.size() > 0)
{
addToCache(this.getText(),(Vector) items.clone());
choices.clear();
for(int i = 0; i < items.size(); i++)
{
choices.addItem(((String [])items.get(i))[0],((String [])items.get(i))[1]);
}
// if there is only one match and it is what is in the
// text field anyways there is no need to show autocompletion
// if(items.size() == 1 && (((String []) items.get(0))[0]).compareTo(this.getText()) == 0)
// {
// choicesPopup.hide();
// } else {
choices.setSelectedIndex(0);
choices.setVisibleItemCount(items.size());
visible = true;
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight());
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight());
choicesPopup.setWidth(this.getOffsetWidth() + "px");
choices.setWidth(this.getOffsetWidth() + "px");
choicesPopup.show();
 
// }
} else {
visible = false;
choicesPopup.hide();
}
}
 
/**
* A mouseclick in the list of items
*/
public void onChange(Widget arg0) {
complete();
}
public void onClick(Widget arg0) {
complete();
}
// add selected item to textbox
protected void complete()
{
if(choices.getItemCount() > 0)
{
this.setText(choices.getItemText(choices.getSelectedIndex()));
currentValue=choices.getValue(choices.getSelectedIndex());
/* if (autoCompleteAsyncTextBoxListeners!= null) {
autoCompleteAsyncTextBoxListeners.fireTextBoxComplete(responseTextHandler,this.getText(),currentValue);
}*/
}
 
visible=false;
items.clear();
choices.clear();
choicesPopup.hide();
}
public void addItem(String item, String value) {
items.add(new String [] {item, value});
}
private void addToCache (String query, Vector result)
{
cache.put(query.toLowerCase(),result);
}
 
private Vector getFromCache (String query)
{
return (Vector) cache.get(query.toLowerCase());
}
 
 
 
public String getValue() {
return currentValue;
}
 
public void setValue(String value) {
this.currentValue=value;
}
 
 
}
/trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java
New file
0,0 → 1,236
/**
David Delon david.delon@clapas.net 2007
*/
 
/*
* LoginDialog.java (DialogBox)
*
* Cas d'utilisation :
* Dialogue de validation de l'identification utilisateur
*
* 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe
* 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies
* 3 : Le dialogue transmet au systeme local les informations d'identification
* 3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4.
* 4 : Cloture du dialogue
* 5 : Appel du dialogue d'importation
*/
 
package org.tela_botanica.client.vues;
 
// TODO : controle de forme sur saisie (regex integree) ...
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
 
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.KeyboardListener;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Position;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.event.KeyListener;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.TextField;
 
public class FormulaireDeConnexionVue extends DialogBox {
 
/**
* Médiateur associé à la vue
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* email saisi
*/
private TextField email=null;
/**
* mot de passe saisi
*/
private TextField motDePasse=null;
 
public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) {
carnetEnLigneMediateur=cm;
 
Panel panneauPrincipalDialogue=new Panel();
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
panneauFormulaire.setTitle("Connexion");
panneauFormulaire.setWidth(350);
panneauFormulaire.setLabelWidth(100);
/*
* E-Mail : Zone_saisie_email
* Mot-de-passe : Zone_saisie_mot_de_passe
* Message d'information
* Bouton_Ok Bouton_Annuler
*/
 
/**
* On ajoute les differents elements du formulaire
*/
// Email
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-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,151
/**
David Delon david.delon@clapas.net 2007
*/
 
/*
* EtatConnexionVue.java : affichage information portant sur le statut de la connexion utilisateur
*
*
* 1: Le programme affiche le statut connecte si l'utilisateur s'est connecte precedemment, sinon s'affiche le statut deconnecte
* 2: Le programme arme les actions liees a la connection ou a la deconnection
* - Connection : affichage de la boite de connexion
* - Deconnexion : appel du service de deconnexion, et appel de la re-initialisation de l'affichage pour le nouvel identifiant utilisateur obtenu (identifiant de session)
*/
 
 
package org.tela_botanica.client.vues;
 
 
 
import org.tela_botanica.client.CarnetEnLigneMediateur;
 
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Widget;
 
import com.gwtext.client.widgets.Panel;
 
 
 
/**
* Un indicateur d'etat de connexion
*
* @author David Delon
*
*/
 
 
 
public class EtatConnexionVue extends Panel {
 
/**
* Médiateur associé à la vue
*/
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ;
/**
* Texte lié à la connexion.
*
*/
private HTML labelEtatConnexion = null;
/**
* Booleen indiquant si utilisateur connecte
*
*/
private boolean connecte = false ;
public EtatConnexionVue(CarnetEnLigneMediateur cm) {
carnetEnLigneMediateur=cm;
 
this.setSize(800,20) ;
this.setBodyBorder(false) ;
this.setBorder(false) ;
// Pas de word wrap
labelEtatConnexion=new HTML("",false);
this.add(labelEtatConnexion);
 
ajouterListeners();
}
public void ajouterListeners() {
 
labelEtatConnexion.addClickListener(
new ClickListener() {
public void onClick(Widget sender) {
// Non connecte ? Lien vers dialogue de connection
if (!connecte) {
carnetEnLigneMediateur.afficherDialogueConnexion();
}
else {
carnetEnLigneMediateur.deconnecterUtilisateur();
 
}
}
}
);
}
 
 
 
/**
* Affichage de l'etat de connexion
* @param text
* @param connecte
*/
public void setEtat(String text, boolean connecte) {
 
labelEtatConnexion.setHTML(text);
this.connecte=connecte;
}
 
 
 
 
}
 
 
/* +--Fin du code ---------------------------------------------------------------------------------------+
* $Log$
* Revision 1.1 2008-06-09 14:19:37 ddelon
* Initialisation observation
*
* Revision 1.2 2008-04-28 13:10:44 ddelon
* Integration MyGwt
*
* Revision 1.1 2008-01-02 21:26:04 ddelon
* mise en place mygwt
*
* Revision 1.6 2007-12-22 14:48:53 ddelon
* Documentation et refactorisation
*
* Revision 1.5 2007-09-17 19:25:34 ddelon
* Documentation
*
*
*/
/trunk/src/org/tela_botanica/client/vues/FormulaireSaisieObservationVue.java
New file
0,0 → 1,190
package org.tela_botanica.client.vues;
 
 
 
import org.tela_botanica.client.observation.ObservationMediateur;
 
 
import com.gwtext.client.core.Position;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.form.DateField;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.layout.ColumnLayout;
import com.gwtext.client.widgets.layout.ColumnLayoutData;
import com.gwtext.client.widgets.layout.FormLayout;
 
/**
* Panneau contenant les infos, les métadonnées et l'arbre des mots clés, il implémente l'interface rafraichissable
* @author aurelien
*
*/
public class FormulaireSaisieObservationVue extends Panel {
 
 
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
private TextField nameAssistant = null;
private LocationAssistantVue locationAssistant = null;
private DateField date = null;
private TextField lieudit = null;
private TextField station = null;
private TextField milieu = null;
private TextField comment = null;
 
/**
* Booleen d'instanciation
*/
boolean estInstancie = false ;
/**
* Constructeur sans argument (privé car ne doit pas être utilisé)
*/
private FormulaireSaisieObservationVue()
{
super() ;
}
/**
* Constructeur avec argument
* @param im
*/
public FormulaireSaisieObservationVue(ObservationMediateur obs)
{
 
// on associe le médiateur
observationMediateur = obs ;
this.setHeader(true);
this.setTitle("Saisie");
this.setCollapsible(true) ;
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT);
panneauFormulaire.setBorder(false);
// Panneau intermediaire qui contient deux colonnes de formulaire
Panel panneauIntermediaire = new Panel();
panneauIntermediaire.setLayout(new ColumnLayout());
panneauIntermediaire.setBorder(false);
//create first panel and add fields to it
Panel panneauPremierColonne = new Panel();
panneauPremierColonne.setLayout(new FormLayout());
panneauPremierColonne.setBorder(false);
 
//create second panel and add fields to it
Panel panneauSecondeColonne = new Panel();
panneauSecondeColonne.setLayout(new FormLayout());
panneauSecondeColonne.setBorder(false);
locationAssistant = new LocationAssistantVue(obs);
panneauPremierColonne.add(locationAssistant);
station = new TextField("Station", "station", 275);
station.setAllowBlank(true);
panneauPremierColonne.add(station);
date = new DateField("Date", "date", 100);
date.setAllowBlank(true);
date.setFormat("d/m/yyyy") ;
panneauPremierColonne.add(date);
nameAssistant = new TextField("Espèce", "espece", 275);
nameAssistant.setAllowBlank(false);
panneauPremierColonne.add(nameAssistant);
comment = new TextField("Notes", "comment", 275);
comment.setAllowBlank(true);
panneauPremierColonne.add(comment);
lieudit = new TextField("Lieu-dit", "lieudit", 275);
lieudit.setAllowBlank(true);
panneauSecondeColonne.add(lieudit);
milieu = new TextField("Milieu", "milieu", 275);
milieu.setAllowBlank(true);
panneauSecondeColonne.add(milieu);
panneauIntermediaire.add(panneauPremierColonne, new ColumnLayoutData(.5));
panneauIntermediaire.add(panneauSecondeColonne, new ColumnLayoutData(.5));
panneauFormulaire.add(panneauIntermediaire);
Button boutonOK = new Button("Ok");
panneauFormulaire.addButton(boutonOK);
Button boutonAnnuler = new Button("Annuler");
panneauFormulaire.addButton(boutonAnnuler);
this.add(panneauFormulaire) ;
this.setAutoHeight(true);
// on ajoute les listeners
ajouterListeners() ;
 
}
private void ajouterListeners()
{
// on ajoute un écouteur
/*validerInfo.addListener(new ButtonListenerAdapter() {
 
// gestion du clic
public void onClick(Button button, EventObject e) {
// lors du clic sur le bouton valider on met à jour les commentaires et la date
// getIMediateur().mettreAJourInfo(commentaireGeneral.getText(), dateImage.getRawValue(), noteVue.getNote()) ;
}
});
*/
}
/**
* Desactive visuellement ce panneau
*/
public void desactiverPanneau()
{
this.setDisabled(true) ;
}
/**
* Active visuellement ce panneau
*/
public void activerPanneau()
{
this.setDisabled(false) ;
}
 
 
}
/trunk/src/org/tela_botanica/client/vues/BarrePaginationObservationVue.java
New file
0,0 → 1,408
package org.tela_botanica.client.vues;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.observation.ObservationMediateur;
 
import com.gwtext.client.core.EventCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Template;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.Toolbar;
import com.gwtext.client.widgets.ToolbarButton;
import com.gwtext.client.widgets.ToolbarTextItem;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.Field;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.form.event.ComboBoxListenerAdapter;
import com.gwtext.client.widgets.form.event.TextFieldListenerAdapter;
 
 
/**
* Barre de pagination asynchrone avec filtrage des touches et accès directs et séquentiels à une page
* @author aurelien
*
*/
public class BarrePaginationObservationVue extends Toolbar implements Rafraichissable {
/**
* Le médiateur associé à la vue
*/
private ObservationMediateur observationMediateur = null;
/**
* Bouton précédent
*/
private ToolbarButton prevPage = new ToolbarButton("<<") ;
/**
* Bouton suivant
*/
private ToolbarButton suivPage = new ToolbarButton(">>") ;
/**
* Numéro de la page courante (attention, commence à zéro pour des raisons pratiques)
*/
private int pageCourante = 0 ;
/**
* Nombre de page total
*/
private int pageTotale = 1 ;
/**
* Nombre d'élements total
*/
private int nbElement = 0 ;
/**
* Nombre d'élément par page
*/
private int taillePage = 0 ;
/**
* Texte statique de la toolbar 1
*/
private ToolbarTextItem page = new ToolbarTextItem("Page ") ;
/**
* Affichage de la page courante
*/
private TextField champPage = new TextField(""+(pageCourante+1)) ;
/**
* Affichage de "sur pageTotale "
*/
private ToolbarTextItem surTotalPage = new ToolbarTextItem(" sur "+pageTotale) ;
/**
* Texte statique de la toolbar 2
*/
private ToolbarTextItem afficherNbElem = new ToolbarTextItem("Afficher ") ;
/**
* Combobox permettant de selectionner le nombre d'élements à afficher par page
* et donc de changer la variable taillePage
*/
private ComboBox selecteurTaillePage = new ComboBox() ;
/**
* Texte statique de la toolbar 3
*/
private ToolbarTextItem nbElemParPage = new ToolbarTextItem(" Observations par page ") ;
/**
* Affiche l'intervalle des éléments contenus dans la page
*/
private ToolbarTextItem intervalleElements = new ToolbarTextItem("Observations "+pageCourante*taillePage+" sur "+nbElement) ;
 
/**
* retourne le mediateur associe à la barre
*/
public ObservationMediateur getImediateur()
{
return observationMediateur;
}
/***
* constructeur sans argument (privé car ne doit pas être utilisé)
*/
private BarrePaginationObservationVue()
{
super() ;
}
/**
* constructeur avec paramètres
* @param im le médiateur à associer à la barre
*/
public BarrePaginationObservationVue(ObservationMediateur im)
{
super() ;
observationMediateur = im ;
// on dispose un peu de texte et quelques espaces pour séparer les éléments
addButton(prevPage) ;
addSpacer() ;
addItem(page) ;
addField(champPage) ;
addItem(surTotalPage) ;
addSpacer() ;
addButton(suivPage) ;
champPage.setWidth(30) ;
addSpacer() ;
addItem(afficherNbElem) ;
// le store contient les valeur possibles pour les tailles de page
final Store store = new SimpleStore(new String[]{"nb_page"}, getNbPages());
store.load();
// le template definit ce que l'on affiche pour chaque element du store dans la combobox
final Template tp = new Template("<div class=\"x-combo-list-item\">"
+ "{nb_page}"
+ "<div class=\"x-clear\"></div></div>");
tp.compile();
selecteurTaillePage.setTpl(tp) ;
selecteurTaillePage.setStore(store) ;
selecteurTaillePage.setWidth(40) ;
selecteurTaillePage.setEditable(false) ;
addField(selecteurTaillePage) ;
selecteurTaillePage.setValue("20") ;
selecteurTaillePage.setWidth(50) ;
addItem(nbElemParPage) ;
// on remplit l'espace pour que l'intervalle d'élement se place à droite de la barre
addFill() ;
addItem(intervalleElements) ;
addSpacer() ;
// on ajoute les différents listeners
ajouterListeners() ;
}
/**
* ajoute les différents listeners nécessaires au bon fonctionnement des éléments de la barre de pagination
*/
private void ajouterListeners()
{
// boutons suivants et précédents
prevPage.addListener(new ButtonListenerAdapter() {
 
public void onClick(Button button, EventObject e) {
// si la page courante n'est pas la première
if(pageCourante > 0)
{
// on décrémente la page courante de 1
pageCourante -- ;
// on rafraichit l'affichage
rafraichirNumeroPage() ;
// et on notifie le médiateur de l'évenement
observationMediateur.changerNumeroPage(pageCourante) ;
}
}
}) ;
suivPage.addListener(new ButtonListenerAdapter() {
public void onClick(Button button, EventObject e) {
// si la page courante n'est pas la dernière
if(pageCourante < pageTotale -1)
{
// on incrémente la page courante de 1
pageCourante ++ ;
// on rafraichit l'affichage
rafraichirNumeroPage() ;
// et on notifie le médiateur de l'évenement
observationMediateur.changerNumeroPage(pageCourante) ;
}
}
}) ;
champPage.addListener(new TextFieldListenerAdapter() {
 
public void onSpecialKey(Field field, EventObject e) {
// on teste si la touche entrée a été pressée
if(e.getKey() == EventObject.ENTER)
{
int nouvellePage = pageCourante ;
// on teste avec parseInt si la valeur entrée est un entier
try
{
nouvellePage = Integer.parseInt(champPage.getRawValue()) ;
}
// si ce n'est pas le cas alors on remet le numéro de page correct
catch(NumberFormatException nfe)
{
rafraichirNumeroPage() ;
champPage.focus(true) ;
return ;
}
// si la conversion reussit on verifie s'il est nécessaire de changer de page
// et si la nouvelle est comprise dans l'intervalle des pages existantes (0..pageTotale)
if(nouvellePage != pageCourante + 1 && nouvellePage > 0 && nouvellePage <= pageTotale)
{
// le cas échéant, on charge la nouvelle page et on notifie le médiateur
changerPageCourante(nouvellePage - 1) ;
observationMediateur.changerNumeroPage(pageCourante);
 
}
else
{
// sinon on reaffiche l'ancien numero de page sans rien changer
rafraichirNumeroPage() ;
champPage.focus(true) ;
}
}
}
public void onFocus(Field field) {
champPage.focus(true) ;
}
});
// pour éviter de se compliquer la vie, on filtre tous les charactères non numériques
champPage.addKeyPressListener(new EventCallback() {
 
public void execute(EventObject e) {
// si c'est un numerique
if(Character.isDigit((char)e.getCharCode()))
{
// on laisse passer
return ;
}
// si c'est la touche entrée ou backspace (valider ou effacer)
if(e.getKey() == EventObject.ENTER || e.getKey() == EventObject.BACKSPACE)
{
// on laisse passer
return ;
}
else
{
// sinon on remet le numero de page correct et on annule l'évenement
rafraichirNumeroPage() ;
e.stopEvent() ;
}
}
}) ;
// listener pour la selection dans la combobox
selecteurTaillePage.addListener(new ComboBoxListenerAdapter() {
public void onSelect(ComboBox comboBox, Record record, int index) {
String nouvelleTaillePageString = comboBox.getStore().getRecordAt(index).getAsString("nb_page") ;
int nouvelleTaillePage = Integer.parseInt(nouvelleTaillePageString) ;
// si la taille de page est différente de l'ancienne
if(nouvelleTaillePage != taillePage)
{
// on la change
changerTaillePage(nouvelleTaillePage) ;
}
// et on met la valeur à jour dans la combobox
comboBox.setValue(nouvelleTaillePageString) ;
}
}) ;
}
/**
* Met à jour les affichage sur les numéros de pages et d'intervalle d'éléments
* à partir des variables de classes
*/
public void rafraichirNumeroPage()
{
surTotalPage.setText(" sur "+pageTotale) ;
if(nbElement == 0)
{
champPage.setValue(""+(0)) ;
// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
intervalleElements.setText("Observations 0 - 0 sur 0") ;
}
else
{
champPage.setValue(""+(pageCourante+1)) ;
// si la page n'est pas la dernière
if(pageCourante + 1 != pageTotale)
{
// sauf pour la dernière page qui contient souvent moins d'élements que le nombre d'élements par page
intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+(pageCourante+1)*taillePage+" sur "+nbElement) ;
}
else
{
// on met simplement à jour l'intervalle qui contient toujours le même nombre d'éléments
intervalleElements.setText("Observations "+pageCourante*taillePage+" - "+nbElement+" sur "+nbElement) ;
}
}
}
/**
* Met à jour la page en cours
* @param nouvellePageCourante la nouvelle page en cours
*/
public void changerPageCourante(int nouvellePageCourante)
{
pageCourante = nouvellePageCourante ;
}
/**
* Methode héritée de l'interface rafraichissable
*/
public void rafraichir(Object nouvelleDonnees,
boolean repandreRaffraichissement) {
// si on reçoit un tableau de int
if(nouvelleDonnees instanceof int[])
{
int [] page = (int[])nouvelleDonnees ;
// le premier élement est le nombre de pages totales
pageTotale = page[0] ;
// le second la page en cours
pageCourante = page[1] ;
// le troisième la taille de la page
taillePage = page[2] ;
// et le dernier le nombre total d'éléments
nbElement = page[3] ;
// si la page courante dépasse la page totale (cas normalement improbable car géré en amont)
// on met le numéro de page à la page courante -1 (car la page courante est comptée à partir
// de zéro)
if(pageCourante >= pageTotale && pageCourante != 0)
{
pageCourante = pageTotale - 1 ;
// le cas échéant on en notifie le médiateur
observationMediateur.changerNumeroPage(pageCourante) ;
}
}
// enfin on rafraichit les informations affichées à partir des nouvelles variables de classes mises à jour
rafraichirNumeroPage() ;
}
/**
* Renvoie les différents intervalles de pages possibles
* @return un tableau de tableau de string qui contient les différentes taille de pages
*/
public String[][] getNbPages()
{
String[][] pages = {{"100"},{"50"},{"30"},{"20"},{"10"}} ;
return pages ;
}
 
/**
* Envoie au médiateur une demande pour modifier la taille de la page
* (qui va à son tour faire les modifications nécessaires)
* @param nouvelleTaillePage la nouvelle taille de page (élement appartenant au tableau renvoyé par getNbPages())
*/
public void changerTaillePage(int nouvelleTaillePage) {
observationMediateur.changerTaillePage(nouvelleTaillePage) ;
}
/**
* Selectionne la valeur correspond à celle passée en paramètre dans la combobox (si elle existe)
* @param nouvelleTaillePage la nouvelle taille de page
*/
public void selectionnerTaillePage(int nouvelleTaillePage) {
selecteurTaillePage.setValue(""+nouvelleTaillePage) ;
}
}