/trunk/src/org/tela_botanica/client/vues/ListeObservationVue.java |
---|
New file |
0,0 → 1,335 |
package org.tela_botanica.client.vues; |
import org.tela_botanica.client.observation.ObservationMediateur; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
import org.tela_botanica.client.interfaces.VueListable; |
import org.tela_botanica.client.vues.BarrePaginationObservationVue; |
import com.gwtext.client.core.Ext; |
import com.gwtext.client.core.ExtElement; |
import com.gwtext.client.data.FieldDef; |
import com.gwtext.client.data.Record; |
import com.gwtext.client.data.RecordDef; |
import com.gwtext.client.data.Store; |
import com.gwtext.client.data.StringFieldDef; |
import com.gwtext.client.widgets.Component; |
import com.gwtext.client.widgets.event.ContainerListenerAdapter; |
import com.gwtext.client.widgets.grid.ColumnConfig; |
import com.gwtext.client.widgets.grid.ColumnModel; |
import com.gwtext.client.widgets.grid.GridPanel; |
import com.gwtext.client.widgets.grid.RowSelectionModel; |
import com.gwtext.client.widgets.grid.event.RowSelectionListenerAdapter; |
/** |
* Liste d'observation composée de ligne d'observation |
* l'interface rafraichissable et l'interface vueListable |
* |
* @author David Delon 2008 |
*/ |
public class ListeObservationVue extends GridPanel implements Rafraichissable, |
VueListable { |
/** |
* Le médiateur associé à la vue |
*/ |
private ObservationMediateur observationMediateur = null; |
/** |
* Config de colonne |
*/ |
private ColumnConfig etatObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig nomSaisiObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig nomRetenuObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig lieuObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig dateObservation; |
/** |
* Config de colonne |
*/ |
private ColumnConfig ordreObservation; |
/** |
* Modele de colonnes |
*/ |
private ColumnModel modeleColonnes; |
/** |
* Store qui contient les données à afficher |
*/ |
private Store st = null; |
/** |
* Barre de pagination |
*/ |
private BarrePaginationObservationVue bt = null ; |
/** |
* Constructeur sans arguments (privé car ne doit pas être utilisé) |
*/ |
private ListeObservationVue() |
{ |
super() ; |
} |
/** |
* Constructeur avec argument |
* @param im le médiateur à associer |
*/ |
public ListeObservationVue(ObservationMediateur obs) { |
this.observationMediateur = obs; |
setHeader(true); |
setTitle("Observations"); |
// on place la barre de pagination |
bt = new BarrePaginationObservationVue(observationMediateur); |
this.setBottomToolbar(bt) ; |
// on construit le modèle de colonnes |
// Le store suivant est ensuite remplacé par le store contenant les données obtenus depuis le serveur (cf rafraichir) |
etatObservation = new ColumnConfig("Transmis", "etat_observation", 50); |
nomSaisiObservation = new ColumnConfig("Nom saisi", "nomSaisi_observation", 200); |
nomRetenuObservation = new ColumnConfig("Nom retenu", "nomRetenu_observation", 200); |
lieuObservation = new ColumnConfig("Lieu", "lieu_observation", 200); |
dateObservation = new ColumnConfig("Date", "date_observation", 70); |
ordreObservation = new ColumnConfig("Ordre", "ordre_observation", 50); |
// on associe le modèle de colonnes |
ColumnConfig[] cm = {etatObservation, nomSaisiObservation, nomRetenuObservation, lieuObservation, dateObservation, ordreObservation}; |
modeleColonnes = new ColumnModel(cm); |
this.setColumnModel(modeleColonnes); |
this.setAutoScroll(true); |
this.setAutoWidth(true); |
this.setEnableColumnResize(true); |
// FIXME: ca ne devrait pas ête obligatoire de fixer la taille |
this.setSize(800,400); |
// creation du store |
FieldDef defEtatObservation = new StringFieldDef("etat_observation"); |
FieldDef defNomSaisiObservation = new StringFieldDef("nomSaisi_observation"); |
FieldDef defNomRetenuObservation = new StringFieldDef("nomRetenu_observation"); |
FieldDef defLieuObservation = new StringFieldDef("lieu_observation"); |
FieldDef defDateObservation = new StringFieldDef("date_observation"); |
FieldDef defOrdreObservation = new StringFieldDef("ordre_observation"); |
FieldDef[] defTab = { defEtatObservation, defNomSaisiObservation, defNomRetenuObservation, |
defLieuObservation, defDateObservation, defOrdreObservation }; |
RecordDef rd = new RecordDef(defTab); |
st = new Store(rd); |
// on associe le store |
this.setStore(st); |
this.getView().setAutoFill(true); |
// on crée un masque de chargement qui s'affichera lors des mises à jour |
this.setLoadMask("Chargement"); |
// on ajoute les listeners |
ajouterListeners(); |
} |
/** |
* Ajoute les listeners pour la gestion des évènements |
*/ |
private void ajouterListeners() { |
this.addListener(new ContainerListenerAdapter() { |
public void onHide(Component component) { |
} |
public void onRender(Component component) { |
} |
public void onShow(Component component) { |
} |
}); |
/* |
this.addGridRowListener(new GridRowListener() { |
// gestion du clic sur une ligne |
public void onRowClick(GridPanel grid, int rowIndex, EventObject e) { |
// on notifie le médiateur et on lui passe le nuémro de ligne |
getobservationMediateur().clicListeImage(rowIndex); |
} |
// gestion du clic droit |
public void onRowContextMenu(GridPanel grid, int rowIndex, |
EventObject e) { |
// on stoppe l'évenement pour empecher le navigateur d'afficher son propre menu |
e.stopEvent() ; |
// on notifie le médiateur en lui passant l'évenement |
getobservationMediateur().montrerContextMenu(e); |
} |
// gestion du double clic |
public void onRowDblClick(GridPanel grid, int rowIndex, |
EventObject e) { |
// on notifie le médiateur en lui passant le numéro de ligne |
getobservationMediateur().doubleClicListeImage(rowIndex); |
} |
}); |
*/ |
this.getSelectionModel().addListener(new RowSelectionListenerAdapter() { |
// gestion de la sélection |
public void onSelectionChange(RowSelectionModel sm) { |
// si on a rien de sélectionné |
if (sm.getCount() <= 0) { |
// on notifie le médiateur (qui désactive notamment l'accès à certaines infos) |
// getobservationMediateur().aucuneSelection(); |
} else { |
// sinon on notifie le médiateur |
// getobservationMediateur().selection(); |
// et on lui demande de synchroniser la selection avec les autres vues |
// getobservationMediateur().synchroniserSelection("liste"); |
} |
} |
}); |
} |
/** |
* Méthode héritée de l'interface VueListable |
* Sélectionne les observations dans la liste suivant les identifiants donnés en paramètres |
*/ |
public String[] getIdSelectionnees() { |
Record[] selection = this.getSelectionModel().getSelections(); |
int taille = selection.length; |
String id_selection[] = new String[taille]; |
for (int i = 0; i < selection.length; i++) { |
id_selection[i] = selection[i].getAsString("ordre_observation"); |
} |
return id_selection; |
} |
/** |
* Méthode héritée de l'interface rafraichissable |
* @param nouvelleDonnees les nouvelles données |
* @param repandreRafraichissement le booleen de notification du rafraichissement |
*/ |
public void rafraichir(Object nouvelleDonnees, |
boolean repandreRafraichissement) { |
// si on reçoit un store |
if (nouvelleDonnees instanceof Store) { |
// on affecte celui-ci comme gestionnaire de données |
st = (Store) nouvelleDonnees; |
st.load(); |
// et on reconfigure et rafraichit la vue |
this.reconfigure(st, this.getColumnModel()); |
demasquerChargement(); |
} |
} |
/** |
* Sélectionne des enregistrements donné |
* @param sel un tableau d'enregistrement à selectionner |
*/ |
public void selectionnerEnregistrements(Record[] sel) { |
getSelectionModel().clearSelections(); |
getSelectionModel().selectRecords(sel); |
} |
/** |
* Accesseur pour la toolbar de pagination |
* @return la toolbar de pagination |
*/ |
public BarrePaginationObservationVue getToolBarVue() |
{ |
return bt ; |
} |
/** |
* Recherche l'élement actuellement affiché et affiche son message de chargement |
*/ |
public void masquerChargement() |
{ |
ExtElement masked = Ext.get(getId()) ; |
// FIXME: parfois null sans raison ! |
if (masked!=null) { |
masked.mask("Chargement") ; |
} |
} |
/** |
* Recherche l'élement actuellement affiché et retire son message de chargement si l'était affiché |
*/ |
public void demasquerChargement() |
{ |
ExtElement masked = Ext.get(getId()) ; |
// FIXME: parfois null sans raison ! |
if (masked!=null) { |
if(masked.isMasked()) |
{ |
masked.unmask() ; |
} |
} |
} |
} |
/trunk/src/org/tela_botanica/client/vues/AutoCompleteAsyncTextBox.java |
---|
New file |
0,0 → 1,360 |
/* |
Auto-Completion Textbox for GWT |
Copyright (C) 2006 Oliver Albers http://gwt.components.googlepages.com/ |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Lesser General Public License for more details. |
You should have received a copy of the GNU Lesser General Public |
License along with this library; if not, write to the Free Software |
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
*/ |
package org.tela_botanica.client.vues; |
// TODO : traiter latence (augmenter en fonction rapidit� saisie + texte vide) |
// TODO : traitement espace apres l'espece (%20) |
// TODO : Utiliser Suggestbox et les Associating Data Transfer Objects (DTOs) with Suggestion Objects |
import com.google.gwt.user.client.ui.KeyboardListener; |
import com.google.gwt.user.client.ui.ListBox; |
import com.google.gwt.user.client.ui.PopupPanel; |
import com.google.gwt.user.client.ui.TextBox; |
import com.google.gwt.user.client.ui.Widget; |
import com.google.gwt.user.client.DOM; |
import com.google.gwt.user.client.Event; |
import java.util.Vector; |
import java.util.HashMap; |
import org.tela_botanica.client.interfaces.FournisseurListe; |
import org.tela_botanica.client.interfaces.Rafraichissable; |
public class AutoCompleteAsyncTextBox extends TextBox implements KeyboardListener { |
// Fournisseur de donnees |
private FournisseurListe fournisseurDeDonnees=null; |
private HashMap cache = new HashMap(); |
private boolean searching = false; |
private Rafraichissable rafraichissable=null; |
protected PopupPanel choicesPopup = new PopupPanel(true); |
protected ListBox choices = new ListBox() { |
public void onBrowserEvent(Event event) { |
if (Event.ONCLICK == DOM.eventGetType(event)) { |
complete(); |
} |
} |
}; |
protected Vector items = new Vector(); |
protected boolean visible = false; |
/** |
* Value linked to current text |
*/ |
protected String currentValue = null; |
/** |
* Default Constructor |
* |
*/ |
public AutoCompleteAsyncTextBox(Rafraichissable r) |
{ |
super(); |
rafraichissable=r; |
this.addKeyboardListener(this); |
choices.sinkEvents(Event.ONCLICK); |
this.setStyleName("AutoCompleteAsyncTextBox"); |
choicesPopup.add(choices); |
choicesPopup.addStyleName("AutoCompleteChoices"); |
choices.setStyleName("list"); |
} |
public void setFournisseurDeDonnees(FournisseurListe fournisseurDeDonnees) { |
this.fournisseurDeDonnees=fournisseurDeDonnees; |
} |
private void doFetchData(String match) { |
String rematch=match.replaceAll(" ","/"); |
rematch=rematch.replaceAll("%",""); |
if (this.fournisseurDeDonnees!=null && searching==false) { |
searching=true; |
fournisseurDeDonnees.obtenirListeDonnees(rafraichissable, rematch); |
} |
} |
public void onKeyDown(Widget arg0, char arg1, int arg2) { |
if(arg1 == KEY_ENTER) |
{ |
enterKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_DOWN) |
{ |
downKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_UP) |
{ |
upKey(arg0, arg1, arg2); |
} |
else if(arg1 == KEY_ESCAPE) |
{ |
escapeKey(arg0, arg1, arg2); |
} |
} |
/** |
* Not used at all (probleme avec ie, qui ne comprend pas les touches meta) |
*/ |
public void onKeyPress(Widget arg0, char arg1, int arg2) { |
} |
// The down key was pressed. |
protected void downKey(Widget arg0, char arg1, int arg2) { |
int selectedIndex = choices.getSelectedIndex(); |
selectedIndex++; |
if (selectedIndex >= choices.getItemCount()) |
{ |
selectedIndex = 0; |
} |
choices.setSelectedIndex(selectedIndex); |
} |
// The up key was pressed. |
protected void upKey(Widget arg0, char arg1, int arg2) { |
int selectedIndex = choices.getSelectedIndex(); |
selectedIndex--; |
if(selectedIndex < 0) |
{ |
selectedIndex = choices.getItemCount() - 1; |
} |
choices.setSelectedIndex(selectedIndex); |
} |
// The enter key was pressed. |
protected void enterKey(Widget arg0, char arg1, int arg2) { |
if(visible) |
{ |
complete(); |
} |
else { |
// Validation de l'entree : appel asynchrone |
/* if (autoCompleteAsyncTextBoxListeners!= null) { |
autoCompleteAsyncTextBoxListeners.fireTextBoxEnter(this,this.getText(),currentValue); |
}*/ |
currentValue=null; |
this.setText(""); |
this.setValue(null); |
} |
} |
//The escape key was pressed. |
protected void escapeKey(Widget arg0, char arg1, int arg2) { |
choices.clear(); |
items.clear(); |
choicesPopup.hide(); |
visible = false; |
} |
// Any other non-special key was pressed. |
protected void otherKey(Widget arg0, char arg1, int arg2) { |
// Lancement appel |
String text = this.getText(); |
if(text.length() > 0) |
{ |
currentValue=null; |
items.clear(); |
if (getFromCache(text)!=null) { |
items=getFromCache(text); |
displayList(); |
} |
else { |
this.doFetchData(text); |
} |
} |
} |
public void onKeyUp(Widget arg0, char arg1, int arg2) { |
switch(arg1) { |
case KEY_ALT: |
case KEY_CTRL: |
case KEY_DOWN: |
case KEY_END: |
case KEY_ENTER: |
case KEY_ESCAPE: |
case KEY_HOME: |
case KEY_LEFT: |
case KEY_PAGEDOWN: |
case KEY_PAGEUP: |
case KEY_RIGHT: |
case KEY_SHIFT: |
case KEY_TAB: |
case KEY_UP: |
break; |
default: |
otherKey(arg0, arg1, arg2); |
break; |
} |
} |
// Display assistant |
public void displayList() { |
searching=false; |
if(this.items.size() > 0) |
{ |
addToCache(this.getText(),(Vector) items.clone()); |
choices.clear(); |
for(int i = 0; i < items.size(); i++) |
{ |
choices.addItem(((String [])items.get(i))[0],((String [])items.get(i))[1]); |
} |
// if there is only one match and it is what is in the |
// text field anyways there is no need to show autocompletion |
// if(items.size() == 1 && (((String []) items.get(0))[0]).compareTo(this.getText()) == 0) |
// { |
// choicesPopup.hide(); |
// } else { |
choices.setSelectedIndex(0); |
choices.setVisibleItemCount(items.size()); |
visible = true; |
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight()); |
choicesPopup.setPopupPosition(this.getAbsoluteLeft(), this.getAbsoluteTop() + this.getOffsetHeight()); |
choicesPopup.setWidth(this.getOffsetWidth() + "px"); |
choices.setWidth(this.getOffsetWidth() + "px"); |
choicesPopup.show(); |
// } |
} else { |
visible = false; |
choicesPopup.hide(); |
} |
} |
/** |
* A mouseclick in the list of items |
*/ |
public void onChange(Widget arg0) { |
complete(); |
} |
public void onClick(Widget arg0) { |
complete(); |
} |
// add selected item to textbox |
protected void complete() |
{ |
if(choices.getItemCount() > 0) |
{ |
this.setText(choices.getItemText(choices.getSelectedIndex())); |
currentValue=choices.getValue(choices.getSelectedIndex()); |
/* if (autoCompleteAsyncTextBoxListeners!= null) { |
autoCompleteAsyncTextBoxListeners.fireTextBoxComplete(responseTextHandler,this.getText(),currentValue); |
}*/ |
} |
visible=false; |
items.clear(); |
choices.clear(); |
choicesPopup.hide(); |
} |
public void addItem(String item, String value) { |
items.add(new String [] {item, value}); |
} |
private void addToCache (String query, Vector result) |
{ |
cache.put(query.toLowerCase(),result); |
} |
private Vector getFromCache (String query) |
{ |
return (Vector) cache.get(query.toLowerCase()); |
} |
public String getValue() { |
return currentValue; |
} |
public void setValue(String value) { |
this.currentValue=value; |
} |
} |
/trunk/src/org/tela_botanica/client/vues/FormulaireDeConnexionVue.java |
---|
New file |
0,0 → 1,236 |
/** |
David Delon david.delon@clapas.net 2007 |
*/ |
/* |
* LoginDialog.java (DialogBox) |
* |
* Cas d'utilisation : |
* Dialogue de validation de l'identification utilisateur |
* |
* 1 : L'utilisateur saisit son identifiant (e-mail) et son mot de passe |
* 2 : Le dialogue controle aupres du systeme distant la validite des informations saisies |
* 3 : Le dialogue transmet au systeme local les informations d'identification |
* 3a : Le dialogue informe l'utilisateur que les elements d'identification ne sont pas valide : retour au point 1, ou passe au point 4. |
* 4 : Cloture du dialogue |
* 5 : Appel du dialogue d'importation |
*/ |
package org.tela_botanica.client.vues; |
// TODO : controle de forme sur saisie (regex integree) ... |
import org.tela_botanica.client.CarnetEnLigneMediateur; |
import com.google.gwt.user.client.ui.DialogBox; |
import com.google.gwt.user.client.ui.KeyboardListener; |
import com.gwtext.client.core.EventObject; |
import com.gwtext.client.core.Position; |
import com.gwtext.client.widgets.Button; |
import com.gwtext.client.widgets.Panel; |
import com.gwtext.client.widgets.event.ButtonListenerAdapter; |
import com.gwtext.client.widgets.event.KeyListener; |
import com.gwtext.client.widgets.form.FormPanel; |
import com.gwtext.client.widgets.form.TextField; |
public class FormulaireDeConnexionVue extends DialogBox { |
/** |
* Médiateur associé à la vue |
*/ |
private CarnetEnLigneMediateur carnetEnLigneMediateur = null ; |
/** |
* email saisi |
*/ |
private TextField email=null; |
/** |
* mot de passe saisi |
*/ |
private TextField motDePasse=null; |
public FormulaireDeConnexionVue(CarnetEnLigneMediateur cm) { |
carnetEnLigneMediateur=cm; |
Panel panneauPrincipalDialogue=new Panel(); |
FormPanel panneauFormulaire = new FormPanel(Position.RIGHT); |
panneauFormulaire.setTitle("Connexion"); |
panneauFormulaire.setWidth(350); |
panneauFormulaire.setLabelWidth(100); |
/* |
* E-Mail : Zone_saisie_email |
* Mot-de-passe : Zone_saisie_mot_de_passe |
* Message d'information |
* Bouton_Ok Bouton_Annuler |
*/ |
/** |
* On ajoute les differents elements du formulaire |
*/ |
email = new TextField("E-mail", "email", 200); |
email.setAllowBlank(false); |
panneauFormulaire.add(email); |
// Mot de passe |
motDePasse = new TextField("Mot de passe", "motDePasse", 200); |
motDePasse.setAllowBlank(false); |
motDePasse.setPassword(true); |
panneauFormulaire.add(motDePasse); |
Button boutonOK = new Button("Ok"); |
panneauFormulaire.addButton(boutonOK); |
Button boutonAnnuler = new Button("Annuler"); |
panneauFormulaire.addButton(boutonAnnuler); |
// Click sur bouton de validation |
boutonOK.addListener( |
new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
} |
); |
// Click sur bouton d'annulation |
boutonAnnuler.addListener( |
new ButtonListenerAdapter() { |
public void onClick(Button button, EventObject e) { |
hide(); |
} |
} |
); |
/** |
* Validation directe depuis un champ de saisie |
* |
*/ |
// gestion de la touche entrée |
email.addKeyListener(EventObject.ENTER, new KeyListener() { |
public void onKey(int key, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
}); |
// Mot de passe |
motDePasse.addKeyListener(EventObject.ENTER, new KeyListener() { |
public void onKey(int key, EventObject e) { |
carnetEnLigneMediateur.connecterUtilisateur(email.getText(),motDePasse.getText()); |
} |
}); |
panneauPrincipalDialogue.add(panneauFormulaire); |
setWidget(panneauPrincipalDialogue); |
} |
/* |
* On sort sur touche echappement |
*/ |
public boolean onKeyDownPreview(char key, int modifiers) { |
switch (key) { |
case KeyboardListener.KEY_ESCAPE: |
hide(); |
break; |
} |
return true; |
} |
public void afficherMessageAlerte() { |
// |
} |
} |
/* +--Fin du code ---------------------------------------------------------------------------------------+ |
* $Log$ |
* Revision 1.1 2008-06-09 14:19:37 ddelon |
* Initialisation observation |
* |
* Revision 1.10 2007-09-17 19:25:34 ddelon |
* Documentation |
* |
* Revision 1.9 2007-05-21 21:03:44 ddelon |
* nettoyage de code |
* |
* Revision 1.8 2007-05-21 18:14:06 ddelon |
* Gestion importation releve locaux |
* |
* Revision 1.7 2007-05-21 11:47:30 ddelon |
* meta cvs |
* |
* Revision 1.6 2007-05-21 11:39:48 ddelon |
* meta cvs |
* |
* Revision 1.5 2007-05-21 11:39:12 ddelon |
* meta cvs |
* |
* Revision 1.4 2007-05-21 11:37:35 ddelon |
* meta cvs |
* |
* Revision 1.3 2007-05-21 11:36:51 ddelon |
* meta cvs |
* |
*/ |
/trunk/src/org/tela_botanica/client/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) ; |
} |
} |